ROOT logo
/**************************************************************************
 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/

/* $Id$ */

// This class is used to store correction maps, raw input and results of the multiplicity
// measurement with the ITS or TPC
// It also contains functions to correct the spectrum using different methods.
// e.g. chi2 minimization and bayesian unfolding
//
//  Author: Jan.Fiete.Grosse-Oetringhaus@cern.ch

#include "AliMultiplicityCorrection.h"

#include <TFile.h>
#include <TH1F.h>
#include <TH2F.h>
#include <TH3F.h>
#include <TDirectory.h>
#include <TCanvas.h>
#include <TString.h>
#include <TF1.h>
#include <TMath.h>
#include <TCollection.h>
#include <TLegend.h>
#include <TLine.h>
#include <TRandom.h>
#include <TProfile.h>
#include <TProfile2D.h>
#include <AliLog.h>

ClassImp(AliMultiplicityCorrection)

// Defined where the efficiency drops below 1/3
// |eta| < 1.4 --> -0.3 ... 0.8
// |eta| < 1.3 --> -1.9 ... 2.4
// |eta| < 1.0 --> -5.6 ... 6.1
//Double_t AliMultiplicityCorrection::fgVtxRangeBegin[kESDHists] = { -10.0, -5.6, -1.9 };
//Double_t AliMultiplicityCorrection::fgVtxRangeEnd[kESDHists] =   {  10.0,  6.1,  2.4 };
Double_t AliMultiplicityCorrection::fgVtxRangeBegin[kESDHists] = { -10.0, -5.5, -1.9 };
Double_t AliMultiplicityCorrection::fgVtxRangeEnd[kESDHists] =   {  10.0,  5.5,  2.4 };

// These are the areas where the quality of the unfolding results are evaluated
// Default defined here, call SetQualityRegions to change them
// unit is in multiplicity (not in bin!)
// SPD:   peak area - flat area - low stat area
Int_t AliMultiplicityCorrection::fgQualityRegionsB[kQualityRegions] = {1,  20, 70};
Int_t AliMultiplicityCorrection::fgQualityRegionsE[kQualityRegions] = {10, 65, 80};

//____________________________________________________________________
void AliMultiplicityCorrection::SetQualityRegions(Bool_t SPDStudy)
{
  //
  // sets the quality region definition to TPC or SPD
  //

  if (SPDStudy)
  {
    // SPD:   peak area - flat area - low stat area
    fgQualityRegionsB[0] = 1;
    fgQualityRegionsE[0] = 10;

    fgQualityRegionsB[1] = 20;
    fgQualityRegionsE[1] = 65;

    fgQualityRegionsB[2] = 70;
    fgQualityRegionsE[2] = 80;

    Printf("AliMultiplicityCorrection::SetQualityRegions --> Enabled quality regions for SPD");
  }
  else
  {
    // TPC:   peak area - flat area - low stat area
    fgQualityRegionsB[0] = 4;
    fgQualityRegionsE[0] = 12;

    fgQualityRegionsB[1] = 25;
    fgQualityRegionsE[1] = 55;

    fgQualityRegionsB[2] = 88;
    fgQualityRegionsE[2] = 108;

    Printf("AliMultiplicityCorrection::SetQualityRegions --> Enabled quality regions for TPC");
  }
}

//____________________________________________________________________
AliMultiplicityCorrection::AliMultiplicityCorrection() :
  TNamed(), fCurrentESD(0), fCurrentCorrelation(0), fCurrentEfficiency(0), fLastBinLimit(0), fLastChi2MC(0), fLastChi2MCLimit(0), fLastChi2Residuals(0), fRatioAverage(0), fVtxBegin(0), fVtxEnd(0)
{
  //
  // default constructor
  //

  for (Int_t i = 0; i < kESDHists; ++i)
  {
    fMultiplicityESD[i] = 0;
    fTriggeredEvents[i] = 0;
    fNoVertexEvents[i] = 0;
  }

  for (Int_t i = 0; i < kMCHists; ++i)
  {
    fMultiplicityVtx[i] = 0;
    fMultiplicityMB[i] = 0;
    fMultiplicityINEL[i] = 0;
    fMultiplicityNSD[i] = 0;
  }

  for (Int_t i = 0; i < kCorrHists; ++i)
  {
    fCorrelation[i] = 0;
    fMultiplicityESDCorrected[i] = 0;
  }

  for (Int_t i = 0; i < kQualityRegions; ++i)
    fQuality[i] = 0;
}

//____________________________________________________________________
AliMultiplicityCorrection* AliMultiplicityCorrection::Open(const char* fileName, const char* folderName)
{
  // opens the given file, reads the multiplicity from the given folder and returns the object
  
  TFile* file = TFile::Open(fileName);
  if (!file)
  {
    Printf("ERROR: Could not open %s", fileName);
    return 0;
  }
  
  Printf("AliMultiplicityCorrection::Open: Reading file %s", fileName);
  
  AliMultiplicityCorrection* mult = new AliMultiplicityCorrection(folderName, folderName);
  mult->LoadHistograms();
  
  // TODO closing the file does not work here, because the histograms cannot be read anymore. LoadHistograms need to be adapted
  
  return mult;
}

//____________________________________________________________________
AliMultiplicityCorrection::AliMultiplicityCorrection(const Char_t* name, const Char_t* title) :
  TNamed(name, title),
  fCurrentESD(0),
  fCurrentCorrelation(0),
  fCurrentEfficiency(0),
  fLastBinLimit(0),
  fLastChi2MC(0),
  fLastChi2MCLimit(0),
  fLastChi2Residuals(0),
  fRatioAverage(0),
  fVtxBegin(0),
  fVtxEnd(0)
{
  //
  // named constructor
  //
  
  // do not add this hists to the directory
  Bool_t oldStatus = TH1::AddDirectoryStatus();
  TH1::AddDirectory(kFALSE);

  /*Float_t binLimitsVtx[] = {-10,-9,-8,-7,-6,-5,-4,-3,-2,-1,0,1,2,3,4,5,6,7,8,9,10};
  Float_t binLimitsN[] = {-0.5, 0.5, 1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5, 8.5, 9.5,
                          10.5, 11.5, 12.5, 13.5, 14.5, 15.5, 16.5, 17.5, 18.5, 19.5,
                          20.5, 21.5, 22.5, 23.5, 24.5, 25.5, 26.5, 27.5, 28.5, 29.5,
                          30.5, 31.5, 32.5, 33.5, 34.5, 35.5, 36.5, 37.5, 38.5, 39.5,
                          40.5, 41.5, 42.5, 43.5, 44.5, 45.5, 46.5, 47.5, 48.5, 49.5,
                          50.5, 55.5, 60.5, 65.5, 70.5, 75.5, 80.5, 85.5, 90.5, 95.5,
                          100.5, 105.5, 110.5, 115.5, 120.5, 125.5, 130.5, 135.5, 140.5, 145.5,
                          150.5, 160.5, 170.5, 180.5, 190.5, 200.5, 210.5, 220.5, 230.5, 240.5,
                          250.5, 275.5, 300.5, 325.5, 350.5, 375.5, 400.5, 425.5, 450.5, 475.5,
                          500.5 };
                                //525.5, 550.5, 575.5, 600.5, 625.5, 650.5, 675.5, 700.5, 725.5,
                          //750.5, 775.5, 800.5, 825.5, 850.5, 875.5, 900.5, 925.5, 950.5, 975.5,
                          //1000.5 };

  #define VTXBINNING 10, binLimitsVtx
  #define NBINNING fgkMaxParams, binLimitsN*/

  #define NBINNING 201, -0.5, 200.5
  
  for (Int_t i = 0; i < kESDHists; ++i)
  {
    fMultiplicityESD[i] = new TH2F(Form("fMultiplicityESD%d", i), "fMultiplicityESD;vtx-z;measured multiplicity;Count", 1, fgVtxRangeBegin[i], fgVtxRangeEnd[i], NBINNING);
    fTriggeredEvents[i] = new TH1F(Form("fTriggeredEvents%d", i), "fTriggeredEvents;measured multiplicity;Count", NBINNING);
    fNoVertexEvents[i] = new TH1F(Form("fNoVertexEvents%d", i), "fNoVertexEvents;generated multiplicity;Count", NBINNING);
  }

  for (Int_t i = 0; i < kMCHists; ++i)
  {
    fMultiplicityVtx[i] = dynamic_cast<TH2F*> (fMultiplicityESD[i%3]->Clone(Form("fMultiplicityVtx%d", i)));
    fMultiplicityVtx[i]->SetTitle("fMultiplicityVtx;vtx-z;Npart");

    fMultiplicityMB[i] = dynamic_cast<TH2F*> (fMultiplicityVtx[i]->Clone(Form("fMultiplicityMB%d", i)));
    fMultiplicityMB[i]->SetTitle("fMultiplicityMB");

    fMultiplicityINEL[i] = dynamic_cast<TH2F*> (fMultiplicityVtx[i]->Clone(Form("fMultiplicityINEL%d", i)));
    fMultiplicityINEL[i]->SetTitle("fMultiplicityINEL");
    
    fMultiplicityNSD[i] = dynamic_cast<TH2F*> (fMultiplicityVtx[i]->Clone(Form("fMultiplicityNSD%d", i)));
    fMultiplicityNSD[i]->SetTitle("fMultiplicityNSD");
  }

  for (Int_t i = 0; i < kCorrHists; ++i)
  {
    fCorrelation[i] = new TH3F(Form("fCorrelation%d", i), "fCorrelation;vtx-z;true multiplicity;measured multiplicity", 1, fgVtxRangeBegin[i%3], fgVtxRangeEnd[i%3], NBINNING, NBINNING);
    fMultiplicityESDCorrected[i] = new TH1F(Form("fMultiplicityESDCorrected%d", i), "fMultiplicityESDCorrected;true multiplicity;Count", NBINNING);
  }

  for (Int_t i = 0; i < kQualityRegions; ++i)
    fQuality[i] = 0;

  TH1::AddDirectory(oldStatus);

  AliUnfolding::SetNbins(120, 120);
  AliUnfolding::SetSkipBinsBegin(1);
  //AliUnfolding::SetNormalizeInput(kTRUE);
}

//____________________________________________________________________
void AliMultiplicityCorrection::Rebin2DY(TH2F*& hist, Int_t nBins, Double_t* newBins) const
{
  // 
  // rebins the y axis of a two-dimensional histogram giving variable size binning (missing in ROOT v5/25/02)
  //
  
  TH2F* temp = new TH2F(hist->GetName(), Form("%s;%s;%s", hist->GetTitle(), hist->GetXaxis()->GetTitle(), hist->GetYaxis()->GetTitle()), hist->GetNbinsX(), hist->GetXaxis()->GetXmin(), hist->GetXaxis()->GetXmax(), nBins, newBins);
  
  for (Int_t x=0; x<=hist->GetNbinsX()+1; x++)
    for (Int_t y=0; y<=hist->GetNbinsY()+1; y++)
      temp->Fill(hist->GetXaxis()->GetBinCenter(x), hist->GetYaxis()->GetBinCenter(y), hist->GetBinContent(x, y));
  
  for (Int_t x=0; x<=temp->GetNbinsX()+1; x++)
    for (Int_t y=0; y<=temp->GetNbinsY()+1; y++)
      temp->SetBinError(x, y, TMath::Sqrt(temp->GetBinContent(x, y)));
      
  delete hist;
  hist = temp;
} 

//____________________________________________________________________
void AliMultiplicityCorrection::Rebin3DY(TH3F*& hist, Int_t nBins, Double_t* newBins) const
{
  // 
  // rebins the y axis of a three-dimensional histogram giving variable size binning (missing in ROOT v5/25/02)
  // this function is a mess - and it should have been Fons who should have gone through the pain of writing it! (JF)
  //
  
  // construct variable size arrays for fixed size binning axes because TH3 lacks some constructors
  Double_t* xBins = new Double_t[hist->GetNbinsX()+1];
  Double_t* zBins = new Double_t[hist->GetNbinsZ()+1];
  
  for (Int_t x=1; x<=hist->GetNbinsX()+1; x++)
  {
    xBins[x-1] = hist->GetXaxis()->GetBinLowEdge(x);
    //Printf("%d %f", x, xBins[x-1]);
  }
  
  for (Int_t z=1; z<=hist->GetNbinsZ()+1; z++)
  {
    zBins[z-1] = hist->GetZaxis()->GetBinLowEdge(z);
    //Printf("%d %f", y, yBins[y-1]);
  }
  
  TH3F* temp = new TH3F(hist->GetName(), Form("%s;%s;%s;%s", hist->GetTitle(), hist->GetXaxis()->GetTitle(), hist->GetYaxis()->GetTitle(), hist->GetZaxis()->GetTitle()), hist->GetNbinsX(), xBins, nBins, newBins, hist->GetNbinsZ(), zBins);
  
  for (Int_t x=0; x<=hist->GetNbinsX()+1; x++)
    for (Int_t y=0; y<=hist->GetNbinsY()+1; y++)
      for (Int_t z=0; z<=hist->GetNbinsZ()+1; z++)
        temp->Fill(hist->GetXaxis()->GetBinCenter(x), hist->GetYaxis()->GetBinCenter(y), hist->GetZaxis()->GetBinCenter(z), hist->GetBinContent(x, y, z));
  
  for (Int_t x=0; x<=temp->GetNbinsX()+1; x++)
    for (Int_t y=0; y<=temp->GetNbinsY()+1; y++)
      for (Int_t z=0; z<=hist->GetNbinsZ()+1; z++)
        temp->SetBinError(x, y, z, TMath::Sqrt(temp->GetBinContent(x, y, z)));
      
  delete[] xBins;
  delete[] zBins;
      
  delete hist;
  hist = temp;
}

//____________________________________________________________________
void AliMultiplicityCorrection::RebinGenerated(Int_t nBins05, Double_t* newBins05, Int_t nBins10, Double_t* newBins10, Int_t nBins13, Double_t* newBins13)
{
  //
  // Rebins the (and only the) generated multiplicity axis 
  //
  
  Printf("Rebinning generated-multiplicity axis...");

  // do not add this hists to the directory
  Bool_t oldStatus = TH1::AddDirectoryStatus();
  TH1::AddDirectory(kFALSE);
  
  if (kESDHists != 3)
    AliFatal("This function only works for three ESD hists!");
  
  for (Int_t i = 0; i < kESDHists; ++i)
  {
    Int_t nBins = -1;
    Double_t* newBins = 0;
    
    switch (i)
    {
      case 0:
        nBins = nBins05;
        newBins = newBins05;
        break;
      case 1:
        nBins = nBins10;
        newBins = newBins10;
        break;
      case 2:
        nBins = nBins13;
        newBins = newBins13;
        break;
    }
  
    // 1D
    // TODO mem leak
    fNoVertexEvents[i] = (TH1F*) fNoVertexEvents[i]->Rebin(nBins, fNoVertexEvents[i]->GetName(), newBins);
    fMultiplicityESDCorrected[i] = (TH1F*) fMultiplicityESDCorrected[i]->Rebin(nBins, fMultiplicityESDCorrected[i]->GetName(), newBins);
  
    // 2D
    Rebin2DY(fMultiplicityVtx[i], nBins, newBins);
    Rebin2DY(fMultiplicityMB[i], nBins, newBins);
    Rebin2DY(fMultiplicityINEL[i], nBins, newBins);
    Rebin2DY(fMultiplicityNSD[i], nBins, newBins);

    // 3D
    Rebin3DY(fCorrelation[i], nBins, newBins);
  }

  TH1::AddDirectory(oldStatus);
}

//____________________________________________________________________
AliMultiplicityCorrection::~AliMultiplicityCorrection()
{
  //
  // Destructor
  //

  Printf("AliMultiplicityCorrection::~AliMultiplicityCorrection called");

  for (Int_t i = 0; i < kESDHists; ++i)
  {
    if (fMultiplicityESD[i])
      delete fMultiplicityESD[i];
    fMultiplicityESD[i] = 0;
    
    if (fTriggeredEvents[i])
      delete fTriggeredEvents[i];
    fTriggeredEvents[i]= 0;
  
    if (fNoVertexEvents[i])
      delete fNoVertexEvents[i];
    fNoVertexEvents[i]= 0;
  }

  for (Int_t i = 0; i < kMCHists; ++i)
  {
    if (fMultiplicityVtx[i])
      delete fMultiplicityVtx[i];
    fMultiplicityVtx[i] = 0;

    if (fMultiplicityMB[i])
      delete fMultiplicityMB[i];
    fMultiplicityMB[i] = 0;

    if (fMultiplicityINEL[i])
      delete fMultiplicityINEL[i];
    fMultiplicityINEL[i] = 0;
  
    if (fMultiplicityNSD[i])
      delete fMultiplicityNSD[i];
    fMultiplicityNSD[i] = 0;
}

  for (Int_t i = 0; i < kCorrHists; ++i)
  {
    if (fCorrelation[i])
      delete fCorrelation[i];
    fCorrelation[i] = 0;

    if (fMultiplicityESDCorrected[i])
      delete fMultiplicityESDCorrected[i];
    fMultiplicityESDCorrected[i] = 0;
  }
}

//____________________________________________________________________
Long64_t AliMultiplicityCorrection::Merge(const TCollection* list)
{
  // Merge a list of AliMultiplicityCorrection objects with this (needed for
  // PROOF).
  // Returns the number of merged objects (including this).

  if (!list)
    return 0;

  if (list->IsEmpty())
    return 1;

  TIterator* iter = list->MakeIterator();
  TObject* obj;

  // collections of all histograms
  TList collections[3*kESDHists+kMCHists*4+kCorrHists*2];

  Int_t count = 0;
  while ((obj = iter->Next())) {

    AliMultiplicityCorrection* entry = dynamic_cast<AliMultiplicityCorrection*> (obj);
    if (entry == 0) 
      continue;

    for (Int_t i = 0; i < kESDHists; ++i)
    {
      collections[i].Add(entry->fMultiplicityESD[i]);
      collections[kESDHists+i].Add(entry->fTriggeredEvents[i]);
      collections[kESDHists*2+i].Add(entry->fNoVertexEvents[i]);
    }

    for (Int_t i = 0; i < kMCHists; ++i)
    {
      collections[3*kESDHists+i].Add(entry->fMultiplicityVtx[i]);
      collections[3*kESDHists+kMCHists+i].Add(entry->fMultiplicityMB[i]);
      collections[3*kESDHists+kMCHists*2+i].Add(entry->fMultiplicityINEL[i]);
      collections[3*kESDHists+kMCHists*3+i].Add(entry->fMultiplicityNSD[i]);
    }

    for (Int_t i = 0; i < kCorrHists; ++i)
      collections[3*kESDHists+kMCHists*4+i].Add(entry->fCorrelation[i]);

    for (Int_t i = 0; i < kCorrHists; ++i)
      collections[3*kESDHists+kMCHists*4+kCorrHists+i].Add(entry->fMultiplicityESDCorrected[i]);

    count++;
  }

  for (Int_t i = 0; i < kESDHists; ++i)
  {
    fMultiplicityESD[i]->Merge(&collections[i]);
    fTriggeredEvents[i]->Merge(&collections[kESDHists+i]);
    fNoVertexEvents[i]->Merge(&collections[2*kESDHists+i]);
  }
  
  for (Int_t i = 0; i < kMCHists; ++i)
  {
    fMultiplicityVtx[i]->Merge(&collections[3*kESDHists+i]);
    fMultiplicityMB[i]->Merge(&collections[3*kESDHists+kMCHists+i]);
    fMultiplicityINEL[i]->Merge(&collections[3*kESDHists+kMCHists*2+i]);
    fMultiplicityNSD[i]->Merge(&collections[3*kESDHists+kMCHists*3+i]);
  }

  for (Int_t i = 0; i < kCorrHists; ++i)
    fCorrelation[i]->Merge(&collections[3*kESDHists+kMCHists*4+i]);

  for (Int_t i = 0; i < kCorrHists; ++i)
    fMultiplicityESDCorrected[i]->Merge(&collections[3*kESDHists+kMCHists*4+kCorrHists+i]);

  delete iter;

  return count+1;
}

//____________________________________________________________________
Bool_t AliMultiplicityCorrection::LoadHistograms(const Char_t* dir)
{
  //
  // loads the histograms from a file
  // if dir is empty a directory with the name of this object is taken (like in SaveHistogram)
  //

  if (!dir)
    dir = GetName();

  if (!gDirectory->cd(dir))
    return kFALSE;

  // store old hists to delete them later
  TList oldObjects;
  oldObjects.SetOwner(1);
  for (Int_t i = 0; i < kESDHists; ++i)
  {
    if (fMultiplicityESD[i])
      oldObjects.Add(fMultiplicityESD[i]);
    if (fTriggeredEvents[i])
      oldObjects.Add(fTriggeredEvents[i]);
    if (fNoVertexEvents[i])
      oldObjects.Add(fNoVertexEvents[i]);
  }
  
  for (Int_t i = 0; i < kMCHists; ++i)
  {
    if (fMultiplicityVtx[i])
      oldObjects.Add(fMultiplicityVtx[i]);
    if (fMultiplicityMB[i])
      oldObjects.Add(fMultiplicityMB[i]);
    if (fMultiplicityINEL[i])
      oldObjects.Add(fMultiplicityINEL[i]);
    if (fMultiplicityNSD[i])
      oldObjects.Add(fMultiplicityNSD[i]);
  }

  for (Int_t i = 0; i < kCorrHists; ++i)
    if (fCorrelation[i])
      oldObjects.Add(fCorrelation[i]);

  // load histograms

  Bool_t success = kTRUE;

  for (Int_t i = 0; i < kESDHists; ++i)
  {
    fMultiplicityESD[i] = dynamic_cast<TH2F*> (gDirectory->Get(fMultiplicityESD[i]->GetName()));
    fTriggeredEvents[i] = dynamic_cast<TH1F*> (gDirectory->Get(fTriggeredEvents[i]->GetName()));
    fNoVertexEvents[i] = dynamic_cast<TH1F*> (gDirectory->Get(fNoVertexEvents[i]->GetName()));
    if (!fMultiplicityESD[i] || !fTriggeredEvents[i] || !fNoVertexEvents[i])
      success = kFALSE;
  }

  for (Int_t i = 0; i < kMCHists; ++i)
  {
    fMultiplicityVtx[i] = dynamic_cast<TH2F*> (gDirectory->Get(fMultiplicityVtx[i]->GetName()));
    fMultiplicityMB[i] = dynamic_cast<TH2F*> (gDirectory->Get(fMultiplicityMB[i]->GetName()));
    fMultiplicityINEL[i] = dynamic_cast<TH2F*> (gDirectory->Get(fMultiplicityINEL[i]->GetName()));
    fMultiplicityNSD[i] = dynamic_cast<TH2F*> (gDirectory->Get(fMultiplicityNSD[i]->GetName()));
    if (!fMultiplicityVtx[i] || !fMultiplicityMB[i] || !fMultiplicityINEL[i])
      success = kFALSE;
  }

  for (Int_t i = 0; i < kCorrHists; ++i)
  {
    fCorrelation[i] = dynamic_cast<TH3F*> (gDirectory->Get(fCorrelation[i]->GetName()));
    if (!fCorrelation[i])
      success = kFALSE;
    fMultiplicityESDCorrected[i] = dynamic_cast<TH1F*> (gDirectory->Get(fMultiplicityESDCorrected[i]->GetName()));
    if (!fMultiplicityESDCorrected[i])
      success = kFALSE;
  }

  gDirectory->cd("..");

  // delete old hists
  oldObjects.Delete();

  return success;
}

//____________________________________________________________________
void AliMultiplicityCorrection::SaveHistograms(const char* dir)
{
  //
  // saves the histograms
  //

  if (!dir)
    dir = GetName();

  gDirectory->mkdir(dir);
  gDirectory->cd(dir);

  for (Int_t i = 0; i < kESDHists; ++i)
  {
    if (fMultiplicityESD[i])
    {
      fMultiplicityESD[i]->Write();
      fMultiplicityESD[i]->ProjectionY(Form("%s_px", fMultiplicityESD[i]->GetName()), 1, fMultiplicityESD[i]->GetNbinsX())->Write();
    }
    if (fTriggeredEvents[i])
      fTriggeredEvents[i]->Write();
    if (fNoVertexEvents[i])
      fNoVertexEvents[i]->Write();
  }

  for (Int_t i = 0; i < kMCHists; ++i)
  {
    if (fMultiplicityVtx[i])
    {
      fMultiplicityVtx[i]->Write();
      fMultiplicityVtx[i]->ProjectionY(Form("%s_px", fMultiplicityVtx[i]->GetName()), 1, fMultiplicityVtx[i]->GetNbinsX())->Write();
    }
    if (fMultiplicityMB[i])
    {
      fMultiplicityMB[i]->Write();
      fMultiplicityMB[i]->ProjectionY(Form("%s_px", fMultiplicityMB[i]->GetName()), 1, fMultiplicityMB[i]->GetNbinsX())->Write();
    }
    if (fMultiplicityINEL[i])
    {
      fMultiplicityINEL[i]->Write();
      fMultiplicityINEL[i]->ProjectionY(Form("%s_px", fMultiplicityINEL[i]->GetName()), 1, fMultiplicityINEL[i]->GetNbinsX())->Write();
    }
    if (fMultiplicityNSD[i])
    {
      fMultiplicityNSD[i]->Write();
      fMultiplicityNSD[i]->ProjectionY(Form("%s_px", fMultiplicityNSD[i]->GetName()), 1, fMultiplicityNSD[i]->GetNbinsX())->Write();
    }
  }

  for (Int_t i = 0; i < kCorrHists; ++i)
  {
    if (fCorrelation[i])
      fCorrelation[i]->Write();
    if (fMultiplicityESDCorrected[i])
      fMultiplicityESDCorrected[i]->Write();
  }

  gDirectory->cd("..");
}

//____________________________________________________________________
void AliMultiplicityCorrection::FillGenerated(Float_t vtx, Bool_t triggered, Bool_t vertex, AliPWG0Helper::MCProcessType processType, Int_t generated05, Int_t generated10, Int_t generated14, Int_t generatedAll)
{
  //
  // Fills an event from MC
  //

  if (triggered)
  {
    fMultiplicityMB[0]->Fill(vtx, generated05);
    fMultiplicityMB[1]->Fill(vtx, generated10);
    fMultiplicityMB[2]->Fill(vtx, generated14);
    fMultiplicityMB[3]->Fill(vtx, generatedAll);

    if (vertex)
    {
      fMultiplicityVtx[0]->Fill(vtx, generated05);
      fMultiplicityVtx[1]->Fill(vtx, generated10);
      fMultiplicityVtx[2]->Fill(vtx, generated14);
      fMultiplicityVtx[3]->Fill(vtx, generatedAll);
    }
  }

  fMultiplicityINEL[0]->Fill(vtx, generated05);
  fMultiplicityINEL[1]->Fill(vtx, generated10);
  fMultiplicityINEL[2]->Fill(vtx, generated14);
  fMultiplicityINEL[3]->Fill(vtx, generatedAll);
  
  if (processType != AliPWG0Helper::kSD)
  {
    fMultiplicityNSD[0]->Fill(vtx, generated05);
    fMultiplicityNSD[1]->Fill(vtx, generated10);
    fMultiplicityNSD[2]->Fill(vtx, generated14);
    fMultiplicityNSD[3]->Fill(vtx, generatedAll);
  }
}

//____________________________________________________________________
void AliMultiplicityCorrection::FillMeasured(Float_t vtx, Int_t measured05, Int_t measured10, Int_t measured14)
{
  //
  // Fills an event from ESD
  //

  fMultiplicityESD[0]->Fill(vtx, measured05);
  fMultiplicityESD[1]->Fill(vtx, measured10);
  fMultiplicityESD[2]->Fill(vtx, measured14);
}

//____________________________________________________________________
void AliMultiplicityCorrection::FillTriggeredEvent(Int_t measured05, Int_t measured10, Int_t measured14)
{
  //
  // fills raw distribution of triggered events
  //
  
  fTriggeredEvents[0]->Fill(measured05);
  fTriggeredEvents[1]->Fill(measured10);
  fTriggeredEvents[2]->Fill(measured14);
}

//____________________________________________________________________
void AliMultiplicityCorrection::FillNoVertexEvent(Float_t vtx, Bool_t vertexReconstructed, Int_t generated05, Int_t generated10, Int_t generated14, Int_t measured05, Int_t measured10, Int_t measured14)
{
  //
  // fills raw distribution of triggered events
  //
  
  if (vtx > fgVtxRangeBegin[0] && vtx < fgVtxRangeEnd[0] && (!vertexReconstructed || measured05 == 0))
    fNoVertexEvents[0]->Fill(generated05);
    
  if (vtx > fgVtxRangeBegin[1] && vtx < fgVtxRangeEnd[1] && (!vertexReconstructed || measured10 == 0))
    fNoVertexEvents[1]->Fill(generated10);
    
  if (vtx > fgVtxRangeBegin[2] && vtx < fgVtxRangeEnd[2] && (!vertexReconstructed || measured14 == 0))
    fNoVertexEvents[2]->Fill(generated14);
}

//____________________________________________________________________
void AliMultiplicityCorrection::FillCorrection(Float_t vtx, Int_t generated05, Int_t generated10, Int_t generated14, Int_t generatedAll, Int_t measured05, Int_t measured10, Int_t measured14)
{
  //
  // Fills an event into the correlation map with the information from MC and ESD
  //

  fCorrelation[0]->Fill(vtx, generated05, measured05);
  fCorrelation[1]->Fill(vtx, generated10, measured10);
  fCorrelation[2]->Fill(vtx, generated14, measured14);

  fCorrelation[3]->Fill(vtx, generatedAll, measured05);
  fCorrelation[4]->Fill(vtx, generatedAll, measured10);
  fCorrelation[5]->Fill(vtx, generatedAll, measured14);
}

//____________________________________________________________________
void AliMultiplicityCorrection::SetupCurrentHists(Int_t inputRange, Bool_t fullPhaseSpace, EventType eventType)
{
  //
  // fills fCurrentESD, fCurrentCorrelation
  // resets fMultiplicityESDCorrected
  //

  Int_t correlationID = inputRange + ((fullPhaseSpace == kFALSE) ? 0 : 4);

  fMultiplicityESDCorrected[correlationID]->Reset();
  fMultiplicityESDCorrected[correlationID]->Sumw2();

  // project without under/overflow bins
  Int_t begin = 1;
  Int_t end = fMultiplicityESD[inputRange]->GetXaxis()->GetNbins();
  if (fVtxEnd > fVtxBegin)
  {
    begin = fVtxBegin;
    end = fVtxEnd;
  }
  fCurrentESD = fMultiplicityESD[inputRange]->ProjectionY("fCurrentESD", begin, end);
  fCurrentESD->Sumw2();

  // empty under/overflow bins in x, otherwise Project3D takes them into account
  TH3* hist = fCorrelation[correlationID];
  for (Int_t y=0; y<=hist->GetYaxis()->GetNbins()+1; ++y)
  {
    for (Int_t z=0; z<=hist->GetZaxis()->GetNbins()+1; ++z)
    {
      hist->SetBinContent(0, y, z, 0);
      hist->SetBinContent(hist->GetXaxis()->GetNbins()+1, y, z, 0);
    }
  }

  if (fVtxEnd > fVtxBegin)
    hist->GetXaxis()->SetRange(fVtxBegin, fVtxEnd);
  
  fCurrentCorrelation = (TH2*) hist->Project3D("zy");
  fCurrentCorrelation->Sumw2();
  
  Printf("AliMultiplicityCorrection::SetupCurrentHists: Statistics information: %.f entries in correlation map; %.f entries in measured spectrum", fCurrentCorrelation->Integral(), fCurrentESD->Integral());

#if 0 // does not help
  // null bins with one entry
  Int_t nNulledBins = 0;
  for (Int_t x=1; x<=fCurrentCorrelation->GetXaxis()->GetNbins(); ++x)
    for (Int_t y=1; y<=fCurrentCorrelation->GetYaxis()->GetNbins(); ++y)
    {
      if (fCurrentCorrelation->GetBinContent(x, y) == 1)
      {
        fCurrentCorrelation->SetBinContent(x, y, 0);
        fCurrentCorrelation->SetBinError(x, y, 0);

        ++nNulledBins;
      }
    }
  Printf("Nulled %d bins", nNulledBins);
#endif

  fCurrentEfficiency = GetEfficiency(inputRange, eventType);
  //fCurrentEfficiency->Rebin(2);
  //fCurrentEfficiency->Scale(0.5);
}

//____________________________________________________________________
TH1* AliMultiplicityCorrection::GetEfficiency(Int_t inputRange, EventType eventType)
{
  //
  // calculates efficiency for given event type
  //
  
  TString name1;
  name1.Form("divisor%d", inputRange);
  
  TString name2;
  name2.Form("CurrentEfficiency%d", inputRange);
  
  TH1* divisor = 0;
  switch (eventType)
  {
    case kTrVtx : break;
    case kMB: divisor = fMultiplicityMB[inputRange]->ProjectionY(name1, 1, fMultiplicityMB[inputRange]->GetNbinsX(), "e"); break;
    case kINEL: divisor = fMultiplicityINEL[inputRange]->ProjectionY(name1, 1, fMultiplicityINEL[inputRange]->GetNbinsX(), "e"); break;
    case kNSD: divisor = fMultiplicityNSD[inputRange]->ProjectionY(name1, 1, fMultiplicityNSD[inputRange]->GetNbinsX(), "e"); break;
  }
  TH1* eff = fMultiplicityVtx[inputRange]->ProjectionY(name2, 1, fMultiplicityVtx[inputRange]->GetNbinsX(), "e");
  
  if (eventType == kTrVtx)
  {
    for (Int_t i=0; i<= eff->GetNbinsX()+1; i++)
      eff->SetBinContent(i, 1);
  }
  else
    eff->Divide(eff, divisor, 1, 1, "B");
    
  return eff;
}

//____________________________________________________________________
TH1* AliMultiplicityCorrection::GetTriggerEfficiency(Int_t inputRange, EventType eventType)
{
  //
  // calculates efficiency for given event type
  //

  TString name1;
  name1.Form("divisor%d", inputRange);
  
  TString name2;
  name2.Form("CurrentEfficiency%d", inputRange);

  TH1* divisor = 0;
  switch (eventType)
  {
    case kTrVtx : AliFatal("Not supported!"); break;
    case kMB: divisor =   fMultiplicityMB[inputRange]->ProjectionY  (name1, 1, fMultiplicityMB[inputRange]->GetNbinsX(), "e"); break;
    case kINEL: divisor = fMultiplicityINEL[inputRange]->ProjectionY(name1, 1, fMultiplicityINEL[inputRange]->GetNbinsX(), "e"); break;
    case kNSD: divisor =  fMultiplicityNSD[inputRange]->ProjectionY (name1, 1, fMultiplicityNSD[inputRange]->GetNbinsX(), "e"); break;
  }
  TH1* eff = fMultiplicityMB[inputRange]->ProjectionY(name2, 1, fMultiplicityMB[inputRange]->GetNbinsX(), "e");
  
  eff->Divide(eff, divisor, 1, 1, "B");
  return eff;
}

//____________________________________________________________________
Int_t AliMultiplicityCorrection::ApplyMinuitFit(Int_t inputRange, Bool_t fullPhaseSpace, EventType eventType, Int_t zeroBinEvents, Bool_t check, TH1* initialConditions, Bool_t errorAsBias)
{
  //
  // correct spectrum using minuit chi2 method
  //
  // for description of parameters, see AliUnfolding::Unfold
  //

  Int_t correlationID = inputRange + ((fullPhaseSpace == kFALSE) ? 0 : 4);
  
  //AliUnfolding::SetCreateOverflowBin(5);
  AliUnfolding::SetUnfoldingMethod(AliUnfolding::kChi2Minimization);
  AliUnfolding::SetMinimumInitialValue(kTRUE, 0.1);
  
  // use here only vtx efficiency (to MB sample) which is always needed if we use the 0 bin
  SetupCurrentHists(inputRange, fullPhaseSpace, (eventType == kTrVtx) ? kTrVtx : kMB);
  
  // TODO set errors on measured with 0.5 * TMath::ChisquareQuantile(0.1, 20000)
  // see PDG: Statistics / Poission or binomial data / Eq. 32.49a/b in 2004 edition
  
  Calculate0Bin(inputRange, eventType, zeroBinEvents);

  Int_t resultCode = -1;
  if (errorAsBias == kFALSE)
  {
    resultCode = AliUnfolding::Unfold(fCurrentCorrelation, fCurrentEfficiency, fCurrentESD, initialConditions, fMultiplicityESDCorrected[correlationID], check);
  }
  else
  {
    resultCode = AliUnfolding::UnfoldGetBias(fCurrentCorrelation, fCurrentEfficiency, fCurrentESD, initialConditions, fMultiplicityESDCorrected[correlationID]);
  }
  
  // HACK store new vertex reco efficiency for bin 0, changing number of events with trigger and vertex in MC map
  if (zeroBinEvents > 0)
  {
    Printf("WARNING: Stored vertex reco efficiency from unfolding for bin 0.");
    fMultiplicityVtx[inputRange]->SetBinContent(1, 1, fMultiplicityMB[inputRange]->GetBinContent(1, 1) * fCurrentEfficiency->GetBinContent(1));
  }
  
  // correct for the trigger bias if requested
  if (eventType > kMB)
  {
    Printf("Applying trigger efficiency");
    TH1* eff = GetTriggerEfficiency(inputRange, eventType);
    for (Int_t i=1; i<=fMultiplicityESDCorrected[correlationID]->GetNbinsX(); i++)
    {
      fMultiplicityESDCorrected[correlationID]->SetBinContent(i, fMultiplicityESDCorrected[correlationID]->GetBinContent(i) / eff->GetBinContent(i));
      fMultiplicityESDCorrected[correlationID]->SetBinError(i, fMultiplicityESDCorrected[correlationID]->GetBinError(i) / eff->GetBinContent(i));
    }
  }
  
  return resultCode;
}

//____________________________________________________________________
void AliMultiplicityCorrection::Calculate0Bin(Int_t inputRange, EventType eventType, Int_t zeroBinEvents)
{
  // fills the 0 bin
  
  if (eventType == kTrVtx)
    return;
  
  Double_t fractionEventsInVertexRange = fMultiplicityESD[inputRange]->Integral(1, fMultiplicityESD[inputRange]->GetXaxis()->GetNbins()) / fMultiplicityESD[inputRange]->Integral(0, fMultiplicityESD[inputRange]->GetXaxis()->GetNbins() + 1);
  
  // difference of fraction that is inside the considered range between triggered events and events with vertex
  // Extension to NSD not needed, INEL and NSD vertex distributions are nature-given and unbiased!
  Double_t differenceVtxDist = (fMultiplicityINEL[inputRange]->Integral(1, fMultiplicityINEL[inputRange]->GetXaxis()->GetNbins()) / fMultiplicityINEL[inputRange]->Integral(0, fMultiplicityINEL[inputRange]->GetXaxis()->GetNbins() + 1)) / (fMultiplicityVtx[inputRange]->Integral(1, fMultiplicityVtx[inputRange]->GetXaxis()->GetNbins()) / fMultiplicityVtx[inputRange]->Integral(0, fMultiplicityVtx[inputRange]->GetXaxis()->GetNbins() + 1));

  Printf("Enabling 0 bin estimate for triggered events without vertex.");
  Printf("  Events in 0 bin: %d", zeroBinEvents);
  Printf("  Fraction in range: %.1f%%", fractionEventsInVertexRange * 100);
  Printf("  Difference Vtx Dist: %f", differenceVtxDist);
  
  AliUnfolding::SetNotFoundEvents(zeroBinEvents * fractionEventsInVertexRange * differenceVtxDist);
}

//____________________________________________________________________
void AliMultiplicityCorrection::FixTriggerEfficiencies(Int_t start)
{
  //
  // sets trigger and vertex efficiencies to 1 for large multiplicities where no event was simulated
  //
  
  for (Int_t etaRange = 0; etaRange < kMCHists; etaRange++)
  {
    for (Int_t i = 1; i <= fMultiplicityINEL[etaRange]->GetNbinsY(); i++)
    {
      if (fMultiplicityINEL[etaRange]->GetYaxis()->GetBinCenter(i) < start)
        continue;
        
      if (fMultiplicityINEL[etaRange]->GetBinContent(1, i) > 0)
        continue;
        
      fMultiplicityINEL[etaRange]->SetBinContent(1, i, 1);
      fMultiplicityNSD[etaRange]->SetBinContent(1, i, 1);
      fMultiplicityMB[etaRange]->SetBinContent(1, i, 1);
      fMultiplicityVtx[etaRange]->SetBinContent(1, i, 1);
    }
  }
}

//____________________________________________________________________
Float_t AliMultiplicityCorrection::GetFraction0Generated(Int_t inputRange)
{
  //
  // returns the fraction of events that have 0 generated particles in the given range among all events without vertex OR 0 tracklets
  //
  
  TH1* multMB = GetNoVertexEvents(inputRange);
  return multMB->GetBinContent(1) / multMB->Integral();
}

//____________________________________________________________________
Int_t AliMultiplicityCorrection::ApplyNBDFit(Int_t inputRange, Bool_t fullPhaseSpace, EventType eventType)
{
  //
  // correct spectrum using minuit chi2 method with a NBD function
  //
  // for description of parameters, see AliUnfolding::Unfold
  //

  Int_t correlationID = inputRange + ((fullPhaseSpace == kFALSE) ? 0 : 4);
  
  AliUnfolding::SetUnfoldingMethod(AliUnfolding::kFunction);
  SetupCurrentHists(inputRange, fullPhaseSpace, eventType);
  
	TF1* func = new TF1("nbd", "[0] * TMath::Gamma([2]+x) / TMath::Gamma([2]) / TMath::Gamma(x+1) * pow([1] / ([1]+[2]), x) * pow(1.0 + [1]/[2], -[2])");
	func->SetParNames("scaling", "averagen", "k");
	func->SetParLimits(0, 0, 1000);
	func->SetParLimits(1, 1, 50);
	func->SetParLimits(2, 1, 10);
	func->SetParameters(1, 10, 2);
  AliUnfolding::SetFunction(func);
  
  return AliUnfolding::Unfold(fCurrentCorrelation, fCurrentEfficiency, fCurrentESD, 0, fMultiplicityESDCorrected[correlationID]);
}

//____________________________________________________________________
void AliMultiplicityCorrection::DrawHistograms()
{
  //
  // draws the histograms of this class
  //

  printf("ESD:\n");

  TCanvas* canvas1 = new TCanvas("fMultiplicityESD", "fMultiplicityESD", 900, 600);
  canvas1->Divide(3, 2);
  for (Int_t i = 0; i < kESDHists; ++i)
  {
    canvas1->cd(i+1);
    fMultiplicityESD[i]->DrawCopy("COLZ");
    printf("%d --> %f\n", i, (Float_t) fMultiplicityESD[i]->ProjectionY()->GetMean());
  }

  printf("Vtx:\n");

  TCanvas* canvas2 = new TCanvas("fMultiplicityMC", "fMultiplicityMC", 900, 600);
  canvas2->Divide(3, 2);
  for (Int_t i = 0; i < kMCHists; ++i)
  {
    canvas2->cd(i+1);
    fMultiplicityVtx[i]->DrawCopy("COLZ");
    printf("%d --> %f\n", i, fMultiplicityVtx[i]->ProjectionY()->GetMean());
  }

  TCanvas* canvas3 = new TCanvas("fCorrelation", "fCorrelation", 900, 900);
  canvas3->Divide(3, 3);
  for (Int_t i = 0; i < kCorrHists; ++i)
  {
    canvas3->cd(i+1);
    TH3* hist = static_cast<TH3*> (fCorrelation[i]->Clone());
    for (Int_t y=1; y<=hist->GetYaxis()->GetNbins(); ++y)
    {
      for (Int_t z=1; z<=hist->GetZaxis()->GetNbins(); ++z)
      {
        hist->SetBinContent(0, y, z, 0);
        hist->SetBinContent(hist->GetXaxis()->GetNbins()+1, y, z, 0);
      }
    }
    TH1* proj = hist->Project3D("zy");
    proj->DrawCopy("COLZ");
  }
}

//____________________________________________________________________
void AliMultiplicityCorrection::DrawComparison(const char* name, Int_t inputRange, Bool_t fullPhaseSpace, Bool_t /*normalizeESD*/, TH1* mcHist, Bool_t simple, EventType eventType)
{
  // draw comparison plots
  
  Int_t esdCorrId = inputRange + ((fullPhaseSpace == kFALSE) ? 0 : 4);
  
  TString tmpStr;
  tmpStr.Form("%s_DrawComparison_%d", name, esdCorrId);

  if (fMultiplicityESDCorrected[esdCorrId]->Integral() == 0)
  {
    printf("ERROR. Unfolded histogram is empty\n");
    return;
  }
  
  Int_t begin = 1;
  Int_t end = fMultiplicityESD[inputRange]->GetXaxis()->GetNbins();
  if (fVtxEnd > fVtxBegin)
  {
    begin = fVtxBegin;
    end = fVtxEnd;
  }
  fCurrentESD = fMultiplicityESD[esdCorrId]->ProjectionY("fCurrentESD", begin, end);
  fCurrentESD->Sumw2();

  mcHist->Sumw2();
  Int_t mcMax = 0;
  for (Int_t i=5; i<=mcHist->GetNbinsX(); ++i)
  {
    if (mcHist->GetBinContent(i) > 0)
      mcMax = (Int_t) mcHist->GetXaxis()->GetBinCenter(i) + 2;
  }
  if (mcMax == 0)
  {
    for (Int_t i=5; i<=fMultiplicityESDCorrected[esdCorrId]->GetNbinsX(); ++i)
      if (fMultiplicityESDCorrected[esdCorrId]->GetBinContent(i) > 1)
        mcMax = (Int_t) fMultiplicityESDCorrected[esdCorrId]->GetXaxis()->GetBinCenter(i) + 2;
  }  
  Printf("AliMultiplicityCorrection::DrawComparison: MC bin limit is %d", mcMax);
  // calculate residual
  Float_t tmp;
  TH1* convolutedProj = (TH1*) GetConvoluted(esdCorrId, eventType)->Clone("convolutedProj");
  TH1* residual = GetResiduals(esdCorrId, eventType, tmp);

  TH1* residualHist = new TH1F("residualHist", "residualHist", 51, -5, 5);

  Float_t chi2 = 0;
  for (Int_t i=1; i<=TMath::Min(residual->GetNbinsX(), 75); ++i)
  {
    Float_t value = residual->GetBinContent(i);
    // TODO has to get a parameter (used in Chi2Function, GetResiduals, and here)
    if (i > 1)
      chi2 += value * value;
    Printf("%d --> %f (%f)", i, value * value, chi2);
    residualHist->Fill(value);
    convolutedProj->SetBinError(i, 0);
  }
  fLastChi2Residuals = chi2;

  //new TCanvas; residualHist->DrawCopy();

  printf("Difference (Residuals) is %f\n", fLastChi2Residuals);

  TCanvas* canvas1 = 0;
  if (simple)
  {
    canvas1 = new TCanvas(tmpStr, tmpStr, 1200, 600);
    canvas1->Divide(2, 1);
  }
  else
  {
    canvas1 = new TCanvas(tmpStr, tmpStr, 1200, 1200);
    canvas1->Divide(2, 3);
  }

  canvas1->cd(1);
  canvas1->cd(1)->SetGridx();
  canvas1->cd(1)->SetGridy();
  canvas1->cd(1)->SetTopMargin(0.05);
  canvas1->cd(1)->SetRightMargin(0.05);
  canvas1->cd(1)->SetLeftMargin(0.12);
  canvas1->cd(1)->SetBottomMargin(0.12);
  TH1* proj = (TH1*) mcHist->Clone("proj");
  if (proj->GetEntries() > 0)
    AliPWG0Helper::NormalizeToBinWidth(proj);

  proj->GetXaxis()->SetRangeUser(0, mcMax);
  proj->GetYaxis()->SetTitleOffset(1.4);
  proj->SetTitle(Form(";True multiplicity in |#eta| < %.1f;Entries", (inputRange+1)*0.5));
  proj->SetStats(kFALSE);

  fMultiplicityESDCorrected[esdCorrId]->GetXaxis()->SetRangeUser(0, mcMax);
  fMultiplicityESDCorrected[esdCorrId]->GetYaxis()->SetRangeUser(0.1, fMultiplicityESDCorrected[esdCorrId]->GetMaximum() * 1.5);
  fMultiplicityESDCorrected[esdCorrId]->GetYaxis()->SetTitleOffset(1.4);
  fMultiplicityESDCorrected[esdCorrId]->SetTitle(Form(";True multiplicity in |#eta| < %.1f;Entries", (inputRange+1)*0.5));
  fMultiplicityESDCorrected[esdCorrId]->SetStats(kFALSE);
  
  fMultiplicityESDCorrected[esdCorrId]->SetLineColor(2);
  fMultiplicityESDCorrected[esdCorrId]->SetMarkerColor(2);

  TH1* esdCorrected = (TH1*) fMultiplicityESDCorrected[esdCorrId]->Clone("esdCorrected");
  AliPWG0Helper::NormalizeToBinWidth(esdCorrected);
  
  if (proj->GetEntries() > 0) {
    proj->DrawCopy("HIST");
    esdCorrected->DrawCopy("SAME HIST E");
  }
  else
    esdCorrected->DrawCopy("HIST E");
    
  gPad->SetLogy();

  TLegend* legend = new TLegend(0.3, 0.8, 0.93, 0.93);
  legend->AddEntry(proj, "True distribution");
  legend->AddEntry(fMultiplicityESDCorrected[esdCorrId], "Unfolded distribution");
  legend->SetFillColor(0);
  legend->SetTextSize(0.04);
  legend->Draw();

  canvas1->cd(2);
  canvas1->cd(2)->SetGridx();
  canvas1->cd(2)->SetGridy();
  canvas1->cd(2)->SetTopMargin(0.05);
  canvas1->cd(2)->SetRightMargin(0.05);
  canvas1->cd(2)->SetLeftMargin(0.12);
  canvas1->cd(2)->SetBottomMargin(0.12);

  gPad->SetLogy();
  fCurrentESD->GetXaxis()->SetRangeUser(0, mcMax);
  fCurrentESD->SetTitle(Form(";Measured multiplicity in |#eta| < %.1f;Entries", (inputRange+1)*0.5));
  fCurrentESD->SetStats(kFALSE);
  fCurrentESD->GetYaxis()->SetTitleOffset(1.4);
  fCurrentESD->DrawCopy("HIST E");

  convolutedProj->SetLineColor(2);
  convolutedProj->SetMarkerColor(2);
  convolutedProj->SetMarkerStyle(5);
  convolutedProj->DrawCopy("HIST SAME P");

  legend = new TLegend(0.3, 0.8, 0.93, 0.93);
  legend->AddEntry(fCurrentESD, "Measured distribution");
  legend->AddEntry(convolutedProj, "R #otimes unfolded distribution", "P");
  legend->SetFillColor(0);
  legend->SetTextSize(0.04);
  legend->Draw();

  if (!simple)
  {
    canvas1->cd(4);
    residual->GetYaxis()->SetRangeUser(-5, 5);
    residual->GetXaxis()->SetRangeUser(0, mcMax);
    residual->SetStats(kFALSE);
    residual->DrawCopy();

    canvas1->cd(5);
    TH1* ratio = (TH1*) fMultiplicityESDCorrected[esdCorrId]->Clone("ratio");
    ratio->Divide(mcHist);
    ratio->SetTitle("Ratio;true multiplicity;Unfolded / MC");
    ratio->GetYaxis()->SetRangeUser(0.5, 1.5);
    ratio->GetXaxis()->SetRangeUser(0, mcMax);
    ratio->SetStats(kFALSE);
    ratio->Draw("HIST");

    // plot (MC - Unfolded) / error (MC)
    canvas1->cd(3);

    TH1* diffMCUnfolded2 = static_cast<TH1*> (proj->Clone("diffMCUnfolded2"));
    diffMCUnfolded2->Add(esdCorrected, -1);

    Int_t ndfQual[kQualityRegions];
    for (Int_t region=0; region<kQualityRegions; ++region)
    {
      fQuality[region] = 0;
      ndfQual[region] = 0;
    }

    Double_t newChi2 = 0;
    Double_t newChi2Limit150 = 0;
    Int_t ndf = 0;
    for (Int_t i=1; i<=diffMCUnfolded2->GetNbinsX(); ++i)
    {
      Double_t value = 0;
      if (proj->GetBinError(i) > 0)
      {
        value = diffMCUnfolded2->GetBinContent(i) / proj->GetBinError(i);
        newChi2 += value * value;
        if (i > 1 && i <= mcMax)
          newChi2Limit150 += value * value;
        ++ndf;

        for (Int_t region=0; region<kQualityRegions; ++region)
          if (diffMCUnfolded2->GetXaxis()->GetBinCenter(i) >= fgQualityRegionsB[region] - 0.1 && diffMCUnfolded2->GetXaxis()->GetBinCenter(i) <= fgQualityRegionsE[region] + 0.1) // 0.1 to avoid e.g. 3.9999 < 4 problem
          {
            fQuality[region] += TMath::Abs(value);
            ++ndfQual[region];
          }
      }

      diffMCUnfolded2->SetBinContent(i, value);
    }

    // normalize region to the number of entries
    for (Int_t region=0; region<kQualityRegions; ++region)
    {
      if (ndfQual[region] > 0)
        fQuality[region] /= ndfQual[region];
      Printf("Quality parameter %d (%d <= mult <= %d) is %f with %d df", region, fgQualityRegionsB[region], fgQualityRegionsE[region], fQuality[region], ndfQual[region]);
    }

    if (mcMax > 1)
    {
      fLastChi2MC = newChi2Limit150 / (mcMax - 1);
      Printf("Chi2 (2..%d) from (MC - Unfolded) / e(MC) is: %.2f ndf is %d --> chi2 / ndf = %.2f", mcMax, newChi2Limit150, mcMax - 1, fLastChi2MC);
    }
    else
      fLastChi2MC = -1;

    Printf("Chi2 (full range) from (MC - Unfolded) / e(MC) is: %.2f ndf is %d --> chi2 / ndf = %.2f", newChi2, ndf, ((ndf > 0) ? newChi2 / ndf : -1));

    diffMCUnfolded2->SetTitle("#chi^{2};true multiplicity;(MC - Unfolded) / e(MC)");
    diffMCUnfolded2->GetYaxis()->SetRangeUser(-5, 5);
    diffMCUnfolded2->GetXaxis()->SetRangeUser(0, mcMax);
    diffMCUnfolded2->DrawCopy("HIST");
    
    canvas1->cd(6);
    // draw penalty factor
    
    TH1* penalty = AliUnfolding::GetPenaltyPlot(fMultiplicityESDCorrected[esdCorrId]);
    penalty->SetStats(0);
    penalty->GetXaxis()->SetRangeUser(0, mcMax);
    penalty->DrawCopy("HIST");
  }
}

//____________________________________________________________________
void AliMultiplicityCorrection::FFT(Int_t dir, Int_t m, Double_t *x, Double_t *y) const
{
/*-------------------------------------------------------------------------
   This computes an in-place complex-to-complex FFT
   x and y are the real and imaginary arrays of 2^m points.
   dir =  1 gives forward transform
   dir = -1 gives reverse transform

     Formula: forward
                  N-1
                  ---
              1   \          - j k 2 pi n / N
      X(n) = ---   >   x(k) e                    = forward transform
              N   /                                n=0..N-1
                  ---
                  k=0

      Formula: reverse
                  N-1
                  ---
                  \          j k 2 pi n / N
      X(n) =       >   x(k) e                    = forward transform
                  /                                n=0..N-1
                  ---
                  k=0
*/

   Long_t   nn, i, i1, j, k, i2, l, l1, l2;
   Double_t c1, c2, tx, ty, t1, t2, u1, u2, z;

   /* Calculate the number of points */
   nn = 1;
   for (i = 0; i < m; i++)
       nn *= 2;

   /* Do the bit reversal */
   i2 = nn >> 1;
   j = 0;
   for (i= 0; i < nn - 1; i++) {
       if (i < j) {
	   tx = x[i];
	   ty = y[i];
	   x[i] = x[j];
	   y[i] = y[j];
	   x[j] = tx;
	   y[j] = ty;
       }
       k = i2;
       while (k <= j) {
	   j -= k;
	   k >>= 1;
       }
       j += k;
   }

   /* Compute the FFT */
   c1 = -1.0;
   c2 = 0.0;
   l2 = 1;
   for (l = 0; l < m; l++) {
       l1 = l2;
       l2 <<= 1;
       u1 = 1.0;
       u2 = 0.0;
       for (j = 0;j < l1; j++) {
	   for (i = j; i < nn; i += l2) {
	       i1 = i + l1;
	       t1 = u1 * x[i1] - u2 * y[i1];
	       t2 = u1 * y[i1] + u2 * x[i1];
	       x[i1] = x[i] - t1;
	       y[i1] = y[i] - t2;
	       x[i] += t1;
	       y[i] += t2;
	   }
	   z =  u1 * c1 - u2 * c2;
	   u2 = u1 * c2 + u2 * c1;
	   u1 = z;
       }
       c2 = TMath::Sqrt((1.0 - c1) / 2.0);
       if (dir == 1)
	   c2 = -c2;
       c1 = TMath::Sqrt((1.0 + c1) / 2.0);
   }

   /* Scaling for forward transform */
   if (dir == 1) {
       for (i=0;i<nn;i++) {
	   x[i] /= (Double_t)nn;
	   y[i] /= (Double_t)nn;
       }
   }
}

//____________________________________________________________________
void AliMultiplicityCorrection::GetComparisonResults(Float_t* const mc, Int_t* const mcLimit, Float_t* const residuals, Float_t* const ratioAverage) const
{
  // Returns the chi2 between the MC and the unfolded ESD as well as between the ESD and the folded unfolded ESD
  // These values are computed during DrawComparison, thus this function picks up the
  // last calculation

  if (mc)
    *mc = fLastChi2MC;
  if (mcLimit)
    *mcLimit = fLastChi2MCLimit;
  if (residuals)
    *residuals = fLastChi2Residuals;
  if (ratioAverage)
    *ratioAverage = fRatioAverage;
}

//____________________________________________________________________
TH2F* AliMultiplicityCorrection::GetMultiplicityMC(Int_t i, EventType eventType) const
{
  //
  // returns the corresponding MC spectrum
  //

  switch (eventType)
  {
    case kTrVtx : return fMultiplicityVtx[i]; break;
    case kMB : return fMultiplicityMB[i]; break;
    case kINEL : return fMultiplicityINEL[i]; break;
    case kNSD : return fMultiplicityNSD[i]; break;
  }

  return 0;
}

//____________________________________________________________________
void AliMultiplicityCorrection::SetMultiplicityMC(Int_t i, EventType eventType, TH2F* const hist)
{
  //
  // returns the corresponding MC spectrum
  //

  switch (eventType)
  {
    case kTrVtx : fMultiplicityVtx[i] = hist; break;
    case kMB : fMultiplicityMB[i] = hist; break;
    case kINEL : fMultiplicityINEL[i] = hist; break;
    case kNSD : fMultiplicityNSD[i] = hist; break;
  }
}

//____________________________________________________________________
TH1* AliMultiplicityCorrection::CalculateStdDev(TH1** results, Int_t max)
{
  // calculate standard deviation of (results[0] - results[k]) k=1...max-1
  // per bin one gets: sigma(r[0] - r[n]) / r[0]

  TH1* standardDeviation = (TH1*) results[0]->Clone("standardDeviation");
  standardDeviation->Reset();

  for (Int_t x=1; x<=results[0]->GetNbinsX(); x++)
  {
    if (results[0]->GetBinContent(x) > 0)
    {
      Double_t average = 0;
      for (Int_t n=1; n<max; ++n)
        average += results[n]->GetBinContent(x) - results[0]->GetBinContent(x);
      average /= max-1;

      Double_t variance = 0;
      for (Int_t n=1; n<max; ++n)
      {
        Double_t value = results[n]->GetBinContent(x) - results[0]->GetBinContent(x) - average;
        variance += value * value;
      }
      variance /= max-1;

      Double_t standardDev = TMath::Sqrt(variance);
      standardDeviation->SetBinContent(x, standardDev / results[0]->GetBinContent(x));
      //Printf("sigma_%d is %f value %f --> error %f", x, standardDev, results[0]->GetBinContent(x), standardDev / results[0]->GetBinContent(x));
    }
  }

  return standardDeviation;
}

//____________________________________________________________________
TH1* AliMultiplicityCorrection::StatisticalUncertainty(AliUnfolding::MethodType methodType, Int_t inputRange, Bool_t fullPhaseSpace, EventType eventType, Int_t zeroBinEvents, Bool_t randomizeMeasured, Bool_t randomizeResponse, const TH1* compareTo)
{
  //
  // evaluates the uncertainty that arises from the non-infinite statistics in the response matrix
  // the function unfolds the spectrum using the default response matrix and several modified ones
  // the modified ones are created by randomizing each cell using poisson statistics with the mean = bin value
  // these unfolded results are compared to the first result gained with the default response OR to the histogram given
  // in <compareTo> (optional)
  //
  // returns the error assigned to the measurement
  //

  Int_t correlationID = inputRange + ((fullPhaseSpace == kFALSE) ? 0 : 4);

  // initialize seed with current time
  gRandom->SetSeed(0);
  
  if (methodType == AliUnfolding::kChi2Minimization)
  {
    Calculate0Bin(inputRange, eventType, zeroBinEvents);
    AliUnfolding::SetMinimumInitialValue(kTRUE, 0.1);
  }
  
  AliUnfolding::SetUnfoldingMethod(methodType);

  const Int_t kErrorIterations = 20;

  TH1* maxError = 0;
  TH1* firstResult = 0;

  TH1** results = new TH1*[kErrorIterations];

  for (Int_t n=0; n<kErrorIterations; ++n)
  {
    Printf("Iteration %d of %d...", n, kErrorIterations);

    SetupCurrentHists(inputRange, fullPhaseSpace, eventType);

    TH1* measured = (TH1*) fCurrentESD->Clone("measured");

    if (n > 0)
    {
      if (randomizeResponse)
      {
        // randomize response matrix
        for (Int_t i=1; i<=fCurrentCorrelation->GetNbinsX(); ++i)
          for (Int_t j=1; j<=fCurrentCorrelation->GetNbinsY(); ++j)
            fCurrentCorrelation->SetBinContent(i, j, gRandom->Poisson(fCurrentCorrelation->GetBinContent(i, j)));
      }

      if (randomizeMeasured)
      {
        // randomize measured spectrum
        for (Int_t x=1; x<=measured->GetNbinsX(); x++) // mult. axis
        {
          Int_t randomValue = gRandom->Poisson(fCurrentESD->GetBinContent(x));
          measured->SetBinContent(x, randomValue);
          measured->SetBinError(x, TMath::Sqrt(randomValue));
        }
      }
    }

    // only for bayesian method we have to do it before the call to Unfold...
    if (methodType == AliUnfolding::kBayesian)
    {
      for (Int_t i=1; i<=fCurrentCorrelation->GetNbinsX(); ++i)
      {
        // with this it is normalized to 1
        Double_t sum = fCurrentCorrelation->Integral(i, i, 1, fCurrentCorrelation->GetNbinsY());

        // with this normalized to the given efficiency
        if (fCurrentEfficiency->GetBinContent(i) > 0)
          sum /= fCurrentEfficiency->GetBinContent(i);
        else
          sum = 0;

        for (Int_t j=1; j<=fCurrentCorrelation->GetNbinsY(); ++j)
        {
          if (sum > 0)
          {
            fCurrentCorrelation->SetBinContent(i, j, fCurrentCorrelation->GetBinContent(i, j) / sum);
            fCurrentCorrelation->SetBinError(i, j, fCurrentCorrelation->GetBinError(i, j) / sum);
          }
          else
          {
            fCurrentCorrelation->SetBinContent(i, j, 0);
            fCurrentCorrelation->SetBinError(i, j, 0);
          }
        }
      }
    }

    TH1* result = 0;
    if (n == 0 && compareTo)
    {
      // in this case we just store the histogram we want to compare to
      result = (TH1*) compareTo->Clone("compareTo");
      result->Sumw2();
    }
    else
    {
      result = (TH1*) fMultiplicityESDCorrected[correlationID]->Clone(Form("result_%d", n));

      Int_t returnCode = AliUnfolding::Unfold(fCurrentCorrelation, fCurrentEfficiency, measured, 0, result);

      if (returnCode != 0)
      {
	n--;
	continue;
      }
    }

    // normalize
    result->Scale(1.0 / result->Integral());

    if (n == 0)
    {
      firstResult = (TH1*) result->Clone("firstResult");

      maxError = (TH1*) result->Clone("maxError");
      maxError->Reset();
    }
    else
    {
      // calculate ratio
      TH1* ratio = (TH1*) firstResult->Clone("ratio");
      ratio->Divide(result);

      // find max. deviation
      for (Int_t x=1; x<=ratio->GetNbinsX(); x++)
        maxError->SetBinContent(x, TMath::Max(maxError->GetBinContent(x), TMath::Abs(1 - ratio->GetBinContent(x))));

      delete ratio;
    }

    results[n] = result;
  }

  // find covariance matrix
  // results[n] is X_x
  // cov. matrix is M_xy = E ( (X_x - E(X_x)) * (X_y - E(X_y))), with E() = expectation value

  Int_t nBins = results[0]->GetNbinsX();
  Float_t lowEdge = results[0]->GetXaxis()->GetBinLowEdge(1);
  Float_t upEdge = results[0]->GetXaxis()->GetBinUpEdge(nBins);

  // find average, E(X)
  TProfile* average = new TProfile("average", "average", nBins, lowEdge, upEdge);
  for (Int_t n=1; n<kErrorIterations; ++n)
    for (Int_t x=1; x<=results[n]->GetNbinsX(); x++)
      average->Fill(results[n]->GetXaxis()->GetBinCenter(x), results[n]->GetBinContent(x));
  //new TCanvas; average->DrawClone();
  
  // find cov. matrix
  TProfile2D* covMatrix = new TProfile2D("covMatrix", "covMatrix", nBins, lowEdge, upEdge, nBins, lowEdge, upEdge);

  for (Int_t n=1; n<kErrorIterations; ++n)
    for (Int_t x=1; x<=results[n]->GetNbinsX(); x++)
      for (Int_t y=1; y<=results[n]->GetNbinsX(); y++)
      {
        // (X_x - E(X_x)) * (X_y - E(X_y)
        Float_t cov = (results[n]->GetBinContent(x) - average->GetBinContent(x)) * (results[n]->GetBinContent(y) - average->GetBinContent(y));
        covMatrix->Fill(results[n]->GetXaxis()->GetBinCenter(x), results[n]->GetXaxis()->GetBinCenter(y), cov);
      }
  TCanvas* c = new TCanvas; c->cd(); covMatrix->DrawCopy("COLZ");

//   // fill 2D histogram that contains deviation from first
//   TH2F* deviations = new TH2F("deviations", "deviations", nBins, lowEdge, upEdge, 1000, -0.01, 0.01);
//   for (Int_t n=1; n<kErrorIterations; ++n)
//     for (Int_t x=1; x<=results[n]->GetNbinsX(); x++)
//       deviations->Fill(results[n]->GetXaxis()->GetBinCenter(x), results[n]->GetBinContent(x) - results[0]->GetBinContent(x));
//   //new TCanvas; deviations->DrawCopy("COLZ");
// 
//   // get standard deviation "by hand"
//   for (Int_t x=1; x<=nBins; x++)
//   {
//     if (results[0]->GetBinContent(x) > 0)
//     {
//       TH1* proj = deviations->ProjectionY("projRMS", x, x, "e");
//       Float_t standardDev = proj->GetRMS(); // this is standard deviation in fact
//       //standardDeviation->SetBinContent(x, standardDev / results[0]->GetBinContent(x));
//       Printf("sigma_%d is %f value %f --> error %f", x, standardDev, results[0]->GetBinContent(x), standardDev / results[0]->GetBinContent(x));
//     }
//   }

  TH1* standardDeviation = CalculateStdDev(results, kErrorIterations);

  // compare maxError to RMS of profile (variable name: average)
  // first: calculate rms in percent of value
  TH1* rmsError = (TH1*) maxError->Clone("rmsError");
  rmsError->Reset();

  // enable error to be standard deviation (see http://root.cern.ch/root/html/TProfile.html#TProfile:SetErrorOption)
  average->SetErrorOption("s");
  for (Int_t x=1; x<=rmsError->GetNbinsX(); x++)
    if (average->GetBinContent(x) > 0)
      rmsError->SetBinContent(x, average->GetBinError(x) / average->GetBinContent(x));

  // find maxError deviation from average (not from "first result"/mc as above)
  TH1* maxError2 = (TH1*) maxError->Clone("maxError2");
  maxError2->Reset();
  for (Int_t n=1; n<kErrorIterations; ++n)
    for (Int_t x=1; x<=results[n]->GetNbinsX(); x++)
      if (average->GetBinContent(x) > 0)
        maxError2->SetBinContent(x, TMath::Max(maxError2->GetBinContent(x), TMath::Abs((results[n]->GetBinContent(x) - average->GetBinContent(x)) / average->GetBinContent(x))));

  //new TCanvas; maxError2->DrawCopy(); rmsError->SetLineColor(2); rmsError->DrawCopy("SAME"); standardDeviation->SetLineColor(3); standardDeviation->DrawCopy("SAME");

  // plot difference between average and MC/first result
  TH1* averageFirstRatio = (TH1*) results[0]->Clone("averageFirstRatio");
  averageFirstRatio->Reset();
  averageFirstRatio->Divide(results[0], average);

  //new TCanvas; results[0]->DrawCopy(); average->SetLineColor(2); average->DrawClone("SAME");
  //new TCanvas; averageFirstRatio->DrawCopy();

  static TH1* temp = 0;
  if (!temp)
  {
    temp = (TH1*) standardDeviation->Clone("temp");
    for (Int_t x=1; x<=results[0]->GetNbinsX(); x++)
      temp->SetBinContent(x, temp->GetBinContent(x) * results[0]->GetBinContent(x));
  }
  else
  {
    // find difference from result[0] as TH2
    TH2F* pulls = new TH2F("pulls", "pulls;multiplicity;difference", nBins, lowEdge, upEdge, 1000, -10, 10);
    for (Int_t n=1; n<kErrorIterations; ++n)
      for (Int_t x=1; x<=results[n]->GetNbinsX(); x++)
        if (temp->GetBinContent(x) > 0)
          pulls->Fill(results[n]->GetXaxis()->GetBinCenter(x), (results[0]->GetBinContent(x) - results[n]->GetBinContent(x)) / temp->GetBinContent(x));
    new TCanvas("pulls", "pulls", 800, 600); pulls->DrawCopy(); pulls->FitSlicesY();
  }

  // clean up
  for (Int_t n=0; n<kErrorIterations; ++n)
    delete results[n];
  delete[] results;

  // fill into result histogram
  for (Int_t i=1; i<=fMultiplicityESDCorrected[correlationID]->GetNbinsX(); ++i)
    fMultiplicityESDCorrected[correlationID]->SetBinContent(i, firstResult->GetBinContent(i));

  for (Int_t i=1; i<=fMultiplicityESDCorrected[correlationID]->GetNbinsX(); ++i)
    fMultiplicityESDCorrected[correlationID]->SetBinError(i, standardDeviation->GetBinContent(i) * fMultiplicityESDCorrected[correlationID]->GetBinContent(i));

  return standardDeviation;
}

//____________________________________________________________________
void AliMultiplicityCorrection::ApplyBayesianMethod(Int_t inputRange, Bool_t fullPhaseSpace, EventType eventType, Float_t regPar, Int_t nIterations, TH1* initialConditions, Int_t determineError)
{
  //
  // correct spectrum using bayesian method
  //
  // determineError: 
  //   0 = no errors
  //   1 = from randomizing
  //   2 = with UnfoldGetBias

  // initialize seed with current time
  gRandom->SetSeed(0);

  SetupCurrentHists(inputRange, fullPhaseSpace, eventType);

  // normalize correction for given nPart
  for (Int_t i=1; i<=fCurrentCorrelation->GetNbinsX(); ++i)
  {
    // with this it is normalized to 1
    Double_t sum = fCurrentCorrelation->Integral(i, i, 1, fCurrentCorrelation->GetNbinsY());

    // with this normalized to the given efficiency
    if (fCurrentEfficiency->GetBinContent(i) > 0)
      sum /= fCurrentEfficiency->GetBinContent(i);
    else
      sum = 0;

    for (Int_t j=1; j<=fCurrentCorrelation->GetNbinsY(); ++j)
    {
      if (sum > 0)
      {
        fCurrentCorrelation->SetBinContent(i, j, fCurrentCorrelation->GetBinContent(i, j) / sum);
        fCurrentCorrelation->SetBinError(i, j, fCurrentCorrelation->GetBinError(i, j) / sum);
      }
      else
      {
        fCurrentCorrelation->SetBinContent(i, j, 0);
        fCurrentCorrelation->SetBinError(i, j, 0);
      }
    }
  }

  Int_t correlationID = inputRange + ((fullPhaseSpace == kFALSE) ? 0 : 4);

  AliUnfolding::SetBayesianParameters(regPar, nIterations);
  AliUnfolding::SetUnfoldingMethod(AliUnfolding::kBayesian);
  
  if (determineError <= 1)
  {
    if (AliUnfolding::Unfold(fCurrentCorrelation, fCurrentEfficiency, fCurrentESD, initialConditions, fMultiplicityESDCorrected[correlationID]) != 0)
      return;
  }
  else if (determineError == 2)
  {
    AliUnfolding::UnfoldGetBias(fCurrentCorrelation, fCurrentEfficiency, fCurrentESD, initialConditions, fMultiplicityESDCorrected[correlationID]);
    return;
  }  

  if (determineError == 0)
  {
    Printf("AliMultiplicityCorrection::ApplyBayesianMethod: WARNING: No errors calculated.");
    return;
  }

  // evaluate errors, this is done by randomizing the measured spectrum following Poission statistics
  // this (new) measured spectrum is then unfolded and the different to the result from the "real" measured
  // spectrum calculated. This is performed N times and the sigma is taken as the statistical
  // error of the unfolding method itself.

  const Int_t kErrorIterations = 20;

  Printf("Spectrum unfolded. Determining error (%d iterations)...", kErrorIterations);

  TH1* randomized = (TH1*) fCurrentESD->Clone("randomized");
  TH1* resultArray[kErrorIterations+1];
  for (Int_t n=0; n<kErrorIterations; ++n)
  {
    // randomize the content of clone following a poisson with the mean = the value of that bin
    for (Int_t x=1; x<=randomized->GetNbinsX(); x++) // mult. axis
    {
      Int_t randomValue = gRandom->Poisson(fCurrentESD->GetBinContent(x));
      //printf("%d --> %d\n", fCurrentESD->GetBinContent(x), randomValue);
      randomized->SetBinContent(x, randomValue);
      randomized->SetBinError(x, TMath::Sqrt(randomValue));
    }

    TH1* result2 = (TH1*) fMultiplicityESDCorrected[correlationID]->Clone("result2");
    result2->Reset();
    if (AliUnfolding::Unfold(fCurrentCorrelation, fCurrentEfficiency, randomized, initialConditions, result2) != 0)
    {
      n--;
      continue;
    }

    resultArray[n+1] = result2;
  }
  delete randomized;

  resultArray[0] = fMultiplicityESDCorrected[correlationID];
  TH1* error = CalculateStdDev(resultArray, kErrorIterations+1);

  for (Int_t n=0; n<kErrorIterations; ++n)
    delete resultArray[n+1];

  Printf("Comparing bias and error:");
  for (Int_t i=1; i<=fMultiplicityESDCorrected[correlationID]->GetNbinsX(); ++i)
  {
    Printf("Bin %d: Content: %f Error: %f Bias: %f", i, fMultiplicityESDCorrected[correlationID]->GetBinContent(i), error->GetBinContent(i) * fMultiplicityESDCorrected[correlationID]->GetBinContent(i), fMultiplicityESDCorrected[correlationID]->GetBinError(i));
    fMultiplicityESDCorrected[correlationID]->SetBinError(i, error->GetBinContent(i) * fMultiplicityESDCorrected[correlationID]->GetBinContent(i));
  }

  delete error;
}

//____________________________________________________________________
Float_t AliMultiplicityCorrection::BayesCovarianceDerivate(Float_t matrixM[251][251], const TH2* hResponse, Int_t k, Int_t i, Int_t r, Int_t u)
{
  //
  // helper function for the covariance matrix of the bayesian method
  //

  Float_t result = 0;

  if (k == u && r == i)
    result += 1.0 / hResponse->GetBinContent(u+1, r+1);

  if (k == u)
    result -= 1.0 / fCurrentEfficiency->GetBinContent(u+1);

  if (r == i)
    result -= matrixM[u][i] * fCurrentEfficiency->GetBinContent(u+1) / hResponse->GetBinContent(u+1, i+1);

  result *= matrixM[k][i];

  return result;
}

//____________________________________________________________________
void AliMultiplicityCorrection::ApplyLaszloMethod(Int_t inputRange, Bool_t fullPhaseSpace, EventType eventType)
{
  //
  // correct spectrum using bayesian method
  //

  Float_t regPar = 0;

  Int_t correlationID = inputRange; // + ((fullPhaseSpace == kFALSE) ? 0 : 4);
  Int_t mcTarget = inputRange; //((fullPhaseSpace == kFALSE) ? inputRange : 4);

  SetupCurrentHists(inputRange, fullPhaseSpace, eventType);
  //normalize ESD
  fCurrentESD->Scale(1.0 / fCurrentESD->Integral());

  // TODO should be taken from correlation map
  //TH1* sumHist = GetMultiplicityMC(inputRange, eventType)->ProjectionY("sumHist", 1, GetMultiplicityMC(inputRange, eventType)->GetNbinsX());

  // normalize correction for given nPart
  for (Int_t i=1; i<=fCurrentCorrelation->GetNbinsX(); ++i)
  {
    Double_t sum = fCurrentCorrelation->Integral(i, i, 1, fCurrentCorrelation->GetNbinsY());
    //Double_t sum = sumHist->GetBinContent(i);
    if (sum <= 0)
      continue;
    for (Int_t j=1; j<=fCurrentCorrelation->GetNbinsY(); ++j)
    {
      // npart sum to 1
      fCurrentCorrelation->SetBinContent(i, j, fCurrentCorrelation->GetBinContent(i, j) / sum);
      fCurrentCorrelation->SetBinError(i, j, fCurrentCorrelation->GetBinError(i, j) / sum);
    }
  }

  new TCanvas;
  fCurrentCorrelation->Draw("COLZ");

  // FAKE
  fCurrentEfficiency = ((TH2*) fCurrentCorrelation)->ProjectionX("eff");

  // pick prior distribution
  TH1F* hPrior = (TH1F*)fCurrentESD->Clone("prior");
  Float_t norm = 1; //hPrior->Integral();
  for (Int_t t=1; t<=hPrior->GetNbinsX(); t++)
    hPrior->SetBinContent(t, hPrior->GetBinContent(t)/norm);

  // zero distribution
  TH1F* zero =  (TH1F*)hPrior->Clone("zero");

  // define temp hist
  TH1F* hTemp = (TH1F*)fCurrentESD->Clone("temp");
  hTemp->Reset();

  // just a shortcut
  TH2F* hResponse = (TH2F*) fCurrentCorrelation;

  // unfold...
  Int_t iterations = 25;
  for (Int_t i=0; i<iterations; i++)
  {
    //printf(" iteration %i \n", i);

    for (Int_t m=1; m<=hResponse->GetNbinsY(); m++)
    {
      Float_t value = 0;
      for (Int_t t = 1; t<=hResponse->GetNbinsX(); t++)
        value += hResponse->GetBinContent(t, m) * hPrior->GetBinContent(t);
      hTemp->SetBinContent(m, value);
      //printf("%d %f %f %f\n", m, zero->GetBinContent(m), hPrior->GetBinContent(m), value);
    }

    // regularization (simple smoothing)
    TH1F* hTrueSmoothed = (TH1F*) hTemp->Clone("truesmoothed");

    for (Int_t t=2; t<hTrueSmoothed->GetNbinsX(); t++)
    {
      Float_t average = (hTemp->GetBinContent(t-1) / hTemp->GetBinWidth(t-1)
                         + hTemp->GetBinContent(t) / hTemp->GetBinWidth(t)
                         + hTemp->GetBinContent(t+1) / hTemp->GetBinWidth(t+1)) / 3.;
      average *= hTrueSmoothed->GetBinWidth(t);

      // weight the average with the regularization parameter
      hTrueSmoothed->SetBinContent(t, (1-regPar) * hTemp->GetBinContent(t) + regPar * average);
    }

    for (Int_t m=1; m<=hResponse->GetNbinsY(); m++)
      hTemp->SetBinContent(m, zero->GetBinContent(m) + hPrior->GetBinContent(m) - hTrueSmoothed->GetBinContent(m));

    // fill guess
    for (Int_t t=1; t<=fMultiplicityESDCorrected[correlationID]->GetNbinsX(); t++)
    {
      fMultiplicityESDCorrected[correlationID]->SetBinContent(t, hTemp->GetBinContent(t));
      fMultiplicityESDCorrected[correlationID]->SetBinError(t, 0.05 * hTemp->GetBinContent(t)); // TODO

      //printf(" bin %d content %f \n", t, fMultiplicityESDCorrected[correlationID]->GetBinContent(t));
    }


    // calculate chi2 (change from last iteration)
    Double_t chi2 = 0;

    // use smoothed true (normalized) as new prior
    norm = 1; //hTrueSmoothed->Integral();

    for (Int_t t=1; t<hTrueSmoothed->GetNbinsX(); t++)
    {
      Float_t newValue = hTemp->GetBinContent(t)/norm;
      Float_t diff = hPrior->GetBinContent(t) - newValue;
      chi2 += (Double_t) diff * diff;

      hPrior->SetBinContent(t, newValue);
    }

    printf("Chi2 of %d iteration = %.10f\n", i, chi2);

    //if (i % 5 == 0)
      DrawComparison(Form("Laszlo_%d", i), inputRange, fullPhaseSpace, kTRUE, GetMultiplicityMC(mcTarget, eventType)->ProjectionY());

    delete hTrueSmoothed;
  } // end of iterations

  DrawComparison("Laszlo", inputRange, fullPhaseSpace, kTRUE, GetMultiplicityMC(mcTarget, eventType)->ProjectionY());
}

//____________________________________________________________________
void AliMultiplicityCorrection::ApplyGaussianMethod(Int_t inputRange, Bool_t fullPhaseSpace)
{
  //
  // correct spectrum using a simple Gaussian approach, that is model-dependent
  //

  Int_t correlationID = inputRange; // + ((fullPhaseSpace == kFALSE) ? 0 : 4);
  Int_t mcTarget = inputRange; //((fullPhaseSpace == kFALSE) ? inputRange : 4);

  SetupCurrentHists(inputRange, fullPhaseSpace, kTrVtx);
  //normalize ESD
  fCurrentESD->Scale(1.0 / fCurrentESD->Integral());

  TH1D* correction = dynamic_cast<TH1D*> (fCurrentESD->Clone("GaussianMean"));
  correction->SetTitle("GaussianMean");

  TH1D* correctionWidth = dynamic_cast<TH1D*> (fCurrentESD->Clone("GaussianWidth"));
  correction->SetTitle("GaussianWidth");

  for (Int_t i=1; i<=fCurrentCorrelation->GetNbinsX(); ++i)
  {
    TH1D* proj = (dynamic_cast<TH2*> (fCurrentCorrelation))->ProjectionX("_px", i, i+1);
    proj->Fit("gaus", "0Q");
    correction->SetBinContent(i, proj->GetFunction("gaus")->GetParameter(1));
    correctionWidth->SetBinContent(i, proj->GetFunction("gaus")->GetParameter(2));
    /*
    // draw for debugging
    new TCanvas;
    proj->DrawCopy();
    proj->GetFunction("gaus")->DrawCopy("SAME");
    */
  }

  TH1* target = fMultiplicityESDCorrected[correlationID];

  Int_t nBins = target->GetNbinsX()*10+1;
  Float_t* binning = new Float_t[nBins];
  for (Int_t i=1; i<=target->GetNbinsX(); ++i)
    for (Int_t j=0; j<10; ++j)
      binning[(i-1)*10 + j] = target->GetXaxis()->GetBinLowEdge(i) + target->GetXaxis()->GetBinWidth(i) / 10 * j;

  binning[nBins-1] = target->GetXaxis()->GetBinUpEdge(target->GetNbinsX());

  TH1F* fineBinned = new TH1F("targetFineBinned", "targetFineBinned", nBins-1, binning);

  for (Int_t i=1; i<=fCurrentCorrelation->GetNbinsX(); ++i)
  {
    Float_t mean = correction->GetBinContent(i);
    Float_t width = correctionWidth->GetBinContent(i);

    Int_t fillBegin = fineBinned->FindBin(mean - width * 5);
    Int_t fillEnd   = fineBinned->FindBin(mean + width * 5);
    //printf("bin %d mean %f width %f, filling from %d to %d\n", i, mean, width, fillBegin, fillEnd);

    for (Int_t j=fillBegin; j <= fillEnd; ++j)
    {
      fineBinned->AddBinContent(j, TMath::Gaus(fineBinned->GetXaxis()->GetBinCenter(j), mean, width, kTRUE) * fCurrentESD->GetBinContent(i));
    }
  }

  for (Int_t i=1; i<=target->GetNbinsX(); ++i)
  {
    Float_t sum = 0;
    for (Int_t j=1; j<=10; ++j)
      sum += fineBinned->GetBinContent((i-1)*10 + j);
    target->SetBinContent(i, sum / 10);
  }

  delete[] binning;

  DrawComparison("Gaussian", inputRange, fullPhaseSpace, kFALSE, GetMultiplicityMC(mcTarget, kTrVtx)->ProjectionY());
}

//____________________________________________________________________
TH1* AliMultiplicityCorrection::GetConvoluted(Int_t i, EventType eventType)
{
  // convolutes the corrected histogram i with the response matrix
  
  TH1* corrected = (TH1*) fMultiplicityESDCorrected[i]->Clone("corrected");
  
  // undo efficiency correction (hist must not be deleted, is reused)
  TH1* efficiency = GetEfficiency(i, eventType);
  //new TCanvas; efficiency->DrawCopy();
  corrected->Multiply(efficiency);
  
  TH2* convoluted = CalculateMultiplicityESD(corrected, i);
  TH1* convolutedProj = convoluted->ProjectionY("GetConvoluted_convolutedProj", 1, convoluted->GetNbinsX());
  
  delete convoluted;
  delete corrected;
  
  return convolutedProj;
}

//____________________________________________________________________
TH1* AliMultiplicityCorrection::GetResiduals(Int_t i, EventType eventType, Float_t& residualSum)
{
  // creates the residual histogram from the corrected histogram i corresponding to an eventType event sample using the corresponding correlation matrix
  // residual is : M - UT / eM
  // residualSum contains the squared sum of the residuals
  
  TH1* corrected = (TH1*) fMultiplicityESDCorrected[i]->Clone("corrected");
  TH1* convolutedProj = GetConvoluted(i, eventType);
  
  Int_t begin = 1;
  Int_t end = fMultiplicityESD[i]->GetNbinsX();
  if (fVtxEnd > fVtxBegin)
  {
    begin = fVtxBegin;
    end = fVtxEnd;
  }
  TH1* measuredProj = fMultiplicityESD[i]->ProjectionY("measuredProj", begin, end);
  
  TH1* residuals = (TH1*) measuredProj->Clone("GetResiduals_residuals");
  residuals->SetTitle(";measured multiplicity;residuals (M-Ut)/e");
  residuals->Add(convolutedProj, -1);
  
  residualSum = 0;
  for (Int_t j=1; j<=residuals->GetNbinsX(); j++)
  {
    if (measuredProj->GetBinContent(j) > 0)
      residuals->SetBinContent(j, residuals->GetBinContent(j) / TMath::Sqrt(measuredProj->GetBinContent(j)));
    residuals->SetBinError(j, 0);
    
    if (j > 1)
      residualSum += residuals->GetBinContent(j) * residuals->GetBinContent(j);
  }
  
  delete corrected;
  delete convolutedProj;
  delete measuredProj;
  
  return residuals;
}

//____________________________________________________________________
TH2F* AliMultiplicityCorrection::CalculateMultiplicityESD(TH1* inputMC, Int_t correlationMap)
{
  // runs the distribution given in inputMC through the response matrix identified by
  // correlationMap and produces a measured distribution
  // although it is a TH2F the vertex axis is not used at the moment and all entries are filled in mid-vertex

  if (!inputMC)
    return 0;

  if (correlationMap < 0 || correlationMap >= kCorrHists)
    return 0;

  // empty under/overflow bins in x, otherwise Project3D takes them into account
  TH3* hist = fCorrelation[correlationMap];
  for (Int_t y=0; y<=hist->GetYaxis()->GetNbins()+1; ++y)
  {
    for (Int_t z=0; z<=hist->GetZaxis()->GetNbins()+1; ++z)
    {
      hist->SetBinContent(0, y, z, 0);
      hist->SetBinContent(hist->GetXaxis()->GetNbins()+1, y, z, 0);
    }
  }

  if (fVtxEnd > fVtxBegin)
    hist->GetXaxis()->SetRange(fVtxBegin, fVtxEnd);
  
  TH2* corr = (TH2*) hist->Project3D("zy");
  //corr->Rebin2D(2, 1);
  corr->Sumw2();
  Printf("Correction histogram used for convolution has %f entries", corr->Integral());

  // normalize correction for given nPart
  for (Int_t i=1; i<=corr->GetNbinsX(); ++i)
  {
    Double_t sum = corr->Integral(i, i, 1, corr->GetNbinsY());
    if (sum <= 0)
      continue;

    for (Int_t j=1; j<=corr->GetNbinsY(); ++j)
    {
      // npart sum to 1
      corr->SetBinContent(i, j, corr->GetBinContent(i, j) / sum);
      corr->SetBinError(i, j, corr->GetBinError(i, j) / sum);
    }
  }

  TH2F* target = static_cast<TH2F*> (fMultiplicityESD[0]->Clone(Form("%s_measured", inputMC->GetName())));
  target->Reset();

  for (Int_t meas=1; meas<=corr->GetNbinsY(); ++meas)
  {
    Float_t measured = 0;
    Float_t error = 0;

    for (Int_t gen=1; gen<=corr->GetNbinsX(); ++gen)
    {
      Int_t mcGenBin = inputMC->GetXaxis()->FindBin(corr->GetXaxis()->GetBinCenter(gen));

      measured += inputMC->GetBinContent(mcGenBin) * corr->GetBinContent(gen, meas);
      // TODO fix error
      error += inputMC->GetBinError(mcGenBin) * corr->GetBinContent(gen, meas);
    }

    //printf("%f +- %f ; %f +- %f \n", inputMC->GetBinContent(meas), inputMC->GetBinError(meas), measured, error);

    target->SetBinContent(1 + target->GetNbinsX() / 2, meas, measured);
    target->SetBinError(1 + target->GetNbinsX() / 2, meas, error);
  }

  return target;
}

//____________________________________________________________________
void AliMultiplicityCorrection::SetGenMeasFromFunc(const TF1* inputMC, Int_t id)
{
  // uses the given function to fill the input MC histogram and generates from that
  // the measured histogram by applying the response matrix
  // this can be used to evaluate if the methods work indepedently of the input
  // distribution
  // WARNING does not respect the vertex distribution, just fills central vertex bin

  if (!inputMC)
    return;

  if (id < 0 || id >= kESDHists)
    return;

  // fill histogram used for random generation
  TH1* tmp = fMultiplicityVtx[id]->ProjectionY("tmp");
  tmp->Reset();

  for (Int_t i=1; i<=tmp->GetNbinsX(); ++i)
    tmp->SetBinContent(i, inputMC->Eval(tmp->GetXaxis()->GetBinCenter(i)) * tmp->GetXaxis()->GetBinWidth(i));
    
  TH1* mcRnd = fMultiplicityVtx[id]->ProjectionY("mcRnd");
  mcRnd->Reset();
  mcRnd->FillRandom(tmp, (Int_t) tmp->Integral());
  
  //new TCanvas; tmp->Draw();
  //new TCanvas; mcRnd->Draw();
  
  // and move into 2d histogram
  TH1* mc = fMultiplicityVtx[id];
  mc->Reset();
  for (Int_t i=1; i<=mc->GetNbinsY(); ++i)
  {
    mc->SetBinContent(mc->GetNbinsX() / 2 + 1, i, mcRnd->GetBinContent(i));
    mc->SetBinError(mc->GetNbinsX() / 2 + 1, i, TMath::Sqrt(mcRnd->GetBinContent(i)));
  }
  
  //new TCanvas; mc->Draw("COLZ");

  // now randomize the measured histogram; funcMeasured is used as pilot function to generated the measured entries
  TH1* funcMeasured = CalculateMultiplicityESD(tmp, id)->ProjectionY("funcMeasured");
  
  //new TCanvas; funcMeasured->Draw();
  
  fMultiplicityESD[id]->Reset();
  
  TH1* measRnd = fMultiplicityESD[id]->ProjectionY("measRnd");
  measRnd->FillRandom(funcMeasured, (Int_t) tmp->Integral());
  
  //new TCanvas; measRnd->Draw();
  
  fMultiplicityESD[id]->Reset();
  for (Int_t i=1; i<=fMultiplicityESD[id]->GetNbinsY(); ++i)
  {
    fMultiplicityESD[id]->SetBinContent(fMultiplicityESD[id]->GetNbinsX() / 2 + 1, i, measRnd->GetBinContent(i));
    fMultiplicityESD[id]->SetBinError(fMultiplicityESD[id]->GetNbinsX() / 2 + 1, i, TMath::Sqrt(measRnd->GetBinContent(i)));
  }
}
 AliMultiplicityCorrection.cxx:1
 AliMultiplicityCorrection.cxx:2
 AliMultiplicityCorrection.cxx:3
 AliMultiplicityCorrection.cxx:4
 AliMultiplicityCorrection.cxx:5
 AliMultiplicityCorrection.cxx:6
 AliMultiplicityCorrection.cxx:7
 AliMultiplicityCorrection.cxx:8
 AliMultiplicityCorrection.cxx:9
 AliMultiplicityCorrection.cxx:10
 AliMultiplicityCorrection.cxx:11
 AliMultiplicityCorrection.cxx:12
 AliMultiplicityCorrection.cxx:13
 AliMultiplicityCorrection.cxx:14
 AliMultiplicityCorrection.cxx:15
 AliMultiplicityCorrection.cxx:16
 AliMultiplicityCorrection.cxx:17
 AliMultiplicityCorrection.cxx:18
 AliMultiplicityCorrection.cxx:19
 AliMultiplicityCorrection.cxx:20
 AliMultiplicityCorrection.cxx:21
 AliMultiplicityCorrection.cxx:22
 AliMultiplicityCorrection.cxx:23
 AliMultiplicityCorrection.cxx:24
 AliMultiplicityCorrection.cxx:25
 AliMultiplicityCorrection.cxx:26
 AliMultiplicityCorrection.cxx:27
 AliMultiplicityCorrection.cxx:28
 AliMultiplicityCorrection.cxx:29
 AliMultiplicityCorrection.cxx:30
 AliMultiplicityCorrection.cxx:31
 AliMultiplicityCorrection.cxx:32
 AliMultiplicityCorrection.cxx:33
 AliMultiplicityCorrection.cxx:34
 AliMultiplicityCorrection.cxx:35
 AliMultiplicityCorrection.cxx:36
 AliMultiplicityCorrection.cxx:37
 AliMultiplicityCorrection.cxx:38
 AliMultiplicityCorrection.cxx:39
 AliMultiplicityCorrection.cxx:40
 AliMultiplicityCorrection.cxx:41
 AliMultiplicityCorrection.cxx:42
 AliMultiplicityCorrection.cxx:43
 AliMultiplicityCorrection.cxx:44
 AliMultiplicityCorrection.cxx:45
 AliMultiplicityCorrection.cxx:46
 AliMultiplicityCorrection.cxx:47
 AliMultiplicityCorrection.cxx:48
 AliMultiplicityCorrection.cxx:49
 AliMultiplicityCorrection.cxx:50
 AliMultiplicityCorrection.cxx:51
 AliMultiplicityCorrection.cxx:52
 AliMultiplicityCorrection.cxx:53
 AliMultiplicityCorrection.cxx:54
 AliMultiplicityCorrection.cxx:55
 AliMultiplicityCorrection.cxx:56
 AliMultiplicityCorrection.cxx:57
 AliMultiplicityCorrection.cxx:58
 AliMultiplicityCorrection.cxx:59
 AliMultiplicityCorrection.cxx:60
 AliMultiplicityCorrection.cxx:61
 AliMultiplicityCorrection.cxx:62
 AliMultiplicityCorrection.cxx:63
 AliMultiplicityCorrection.cxx:64
 AliMultiplicityCorrection.cxx:65
 AliMultiplicityCorrection.cxx:66
 AliMultiplicityCorrection.cxx:67
 AliMultiplicityCorrection.cxx:68
 AliMultiplicityCorrection.cxx:69
 AliMultiplicityCorrection.cxx:70
 AliMultiplicityCorrection.cxx:71
 AliMultiplicityCorrection.cxx:72
 AliMultiplicityCorrection.cxx:73
 AliMultiplicityCorrection.cxx:74
 AliMultiplicityCorrection.cxx:75
 AliMultiplicityCorrection.cxx:76
 AliMultiplicityCorrection.cxx:77
 AliMultiplicityCorrection.cxx:78
 AliMultiplicityCorrection.cxx:79
 AliMultiplicityCorrection.cxx:80
 AliMultiplicityCorrection.cxx:81
 AliMultiplicityCorrection.cxx:82
 AliMultiplicityCorrection.cxx:83
 AliMultiplicityCorrection.cxx:84
 AliMultiplicityCorrection.cxx:85
 AliMultiplicityCorrection.cxx:86
 AliMultiplicityCorrection.cxx:87
 AliMultiplicityCorrection.cxx:88
 AliMultiplicityCorrection.cxx:89
 AliMultiplicityCorrection.cxx:90
 AliMultiplicityCorrection.cxx:91
 AliMultiplicityCorrection.cxx:92
 AliMultiplicityCorrection.cxx:93
 AliMultiplicityCorrection.cxx:94
 AliMultiplicityCorrection.cxx:95
 AliMultiplicityCorrection.cxx:96
 AliMultiplicityCorrection.cxx:97
 AliMultiplicityCorrection.cxx:98
 AliMultiplicityCorrection.cxx:99
 AliMultiplicityCorrection.cxx:100
 AliMultiplicityCorrection.cxx:101
 AliMultiplicityCorrection.cxx:102
 AliMultiplicityCorrection.cxx:103
 AliMultiplicityCorrection.cxx:104
 AliMultiplicityCorrection.cxx:105
 AliMultiplicityCorrection.cxx:106
 AliMultiplicityCorrection.cxx:107
 AliMultiplicityCorrection.cxx:108
 AliMultiplicityCorrection.cxx:109
 AliMultiplicityCorrection.cxx:110
 AliMultiplicityCorrection.cxx:111
 AliMultiplicityCorrection.cxx:112
 AliMultiplicityCorrection.cxx:113
 AliMultiplicityCorrection.cxx:114
 AliMultiplicityCorrection.cxx:115
 AliMultiplicityCorrection.cxx:116
 AliMultiplicityCorrection.cxx:117
 AliMultiplicityCorrection.cxx:118
 AliMultiplicityCorrection.cxx:119
 AliMultiplicityCorrection.cxx:120
 AliMultiplicityCorrection.cxx:121
 AliMultiplicityCorrection.cxx:122
 AliMultiplicityCorrection.cxx:123
 AliMultiplicityCorrection.cxx:124
 AliMultiplicityCorrection.cxx:125
 AliMultiplicityCorrection.cxx:126
 AliMultiplicityCorrection.cxx:127
 AliMultiplicityCorrection.cxx:128
 AliMultiplicityCorrection.cxx:129
 AliMultiplicityCorrection.cxx:130
 AliMultiplicityCorrection.cxx:131
 AliMultiplicityCorrection.cxx:132
 AliMultiplicityCorrection.cxx:133
 AliMultiplicityCorrection.cxx:134
 AliMultiplicityCorrection.cxx:135
 AliMultiplicityCorrection.cxx:136
 AliMultiplicityCorrection.cxx:137
 AliMultiplicityCorrection.cxx:138
 AliMultiplicityCorrection.cxx:139
 AliMultiplicityCorrection.cxx:140
 AliMultiplicityCorrection.cxx:141
 AliMultiplicityCorrection.cxx:142
 AliMultiplicityCorrection.cxx:143
 AliMultiplicityCorrection.cxx:144
 AliMultiplicityCorrection.cxx:145
 AliMultiplicityCorrection.cxx:146
 AliMultiplicityCorrection.cxx:147
 AliMultiplicityCorrection.cxx:148
 AliMultiplicityCorrection.cxx:149
 AliMultiplicityCorrection.cxx:150
 AliMultiplicityCorrection.cxx:151
 AliMultiplicityCorrection.cxx:152
 AliMultiplicityCorrection.cxx:153
 AliMultiplicityCorrection.cxx:154
 AliMultiplicityCorrection.cxx:155
 AliMultiplicityCorrection.cxx:156
 AliMultiplicityCorrection.cxx:157
 AliMultiplicityCorrection.cxx:158
 AliMultiplicityCorrection.cxx:159
 AliMultiplicityCorrection.cxx:160
 AliMultiplicityCorrection.cxx:161
 AliMultiplicityCorrection.cxx:162
 AliMultiplicityCorrection.cxx:163
 AliMultiplicityCorrection.cxx:164
 AliMultiplicityCorrection.cxx:165
 AliMultiplicityCorrection.cxx:166
 AliMultiplicityCorrection.cxx:167
 AliMultiplicityCorrection.cxx:168
 AliMultiplicityCorrection.cxx:169
 AliMultiplicityCorrection.cxx:170
 AliMultiplicityCorrection.cxx:171
 AliMultiplicityCorrection.cxx:172
 AliMultiplicityCorrection.cxx:173
 AliMultiplicityCorrection.cxx:174
 AliMultiplicityCorrection.cxx:175
 AliMultiplicityCorrection.cxx:176
 AliMultiplicityCorrection.cxx:177
 AliMultiplicityCorrection.cxx:178
 AliMultiplicityCorrection.cxx:179
 AliMultiplicityCorrection.cxx:180
 AliMultiplicityCorrection.cxx:181
 AliMultiplicityCorrection.cxx:182
 AliMultiplicityCorrection.cxx:183
 AliMultiplicityCorrection.cxx:184
 AliMultiplicityCorrection.cxx:185
 AliMultiplicityCorrection.cxx:186
 AliMultiplicityCorrection.cxx:187
 AliMultiplicityCorrection.cxx:188
 AliMultiplicityCorrection.cxx:189
 AliMultiplicityCorrection.cxx:190
 AliMultiplicityCorrection.cxx:191
 AliMultiplicityCorrection.cxx:192
 AliMultiplicityCorrection.cxx:193
 AliMultiplicityCorrection.cxx:194
 AliMultiplicityCorrection.cxx:195
 AliMultiplicityCorrection.cxx:196
 AliMultiplicityCorrection.cxx:197
 AliMultiplicityCorrection.cxx:198
 AliMultiplicityCorrection.cxx:199
 AliMultiplicityCorrection.cxx:200
 AliMultiplicityCorrection.cxx:201
 AliMultiplicityCorrection.cxx:202
 AliMultiplicityCorrection.cxx:203
 AliMultiplicityCorrection.cxx:204
 AliMultiplicityCorrection.cxx:205
 AliMultiplicityCorrection.cxx:206
 AliMultiplicityCorrection.cxx:207
 AliMultiplicityCorrection.cxx:208
 AliMultiplicityCorrection.cxx:209
 AliMultiplicityCorrection.cxx:210
 AliMultiplicityCorrection.cxx:211
 AliMultiplicityCorrection.cxx:212
 AliMultiplicityCorrection.cxx:213
 AliMultiplicityCorrection.cxx:214
 AliMultiplicityCorrection.cxx:215
 AliMultiplicityCorrection.cxx:216
 AliMultiplicityCorrection.cxx:217
 AliMultiplicityCorrection.cxx:218
 AliMultiplicityCorrection.cxx:219
 AliMultiplicityCorrection.cxx:220
 AliMultiplicityCorrection.cxx:221
 AliMultiplicityCorrection.cxx:222
 AliMultiplicityCorrection.cxx:223
 AliMultiplicityCorrection.cxx:224
 AliMultiplicityCorrection.cxx:225
 AliMultiplicityCorrection.cxx:226
 AliMultiplicityCorrection.cxx:227
 AliMultiplicityCorrection.cxx:228
 AliMultiplicityCorrection.cxx:229
 AliMultiplicityCorrection.cxx:230
 AliMultiplicityCorrection.cxx:231
 AliMultiplicityCorrection.cxx:232
 AliMultiplicityCorrection.cxx:233
 AliMultiplicityCorrection.cxx:234
 AliMultiplicityCorrection.cxx:235
 AliMultiplicityCorrection.cxx:236
 AliMultiplicityCorrection.cxx:237
 AliMultiplicityCorrection.cxx:238
 AliMultiplicityCorrection.cxx:239
 AliMultiplicityCorrection.cxx:240
 AliMultiplicityCorrection.cxx:241
 AliMultiplicityCorrection.cxx:242
 AliMultiplicityCorrection.cxx:243
 AliMultiplicityCorrection.cxx:244
 AliMultiplicityCorrection.cxx:245
 AliMultiplicityCorrection.cxx:246
 AliMultiplicityCorrection.cxx:247
 AliMultiplicityCorrection.cxx:248
 AliMultiplicityCorrection.cxx:249
 AliMultiplicityCorrection.cxx:250
 AliMultiplicityCorrection.cxx:251
 AliMultiplicityCorrection.cxx:252
 AliMultiplicityCorrection.cxx:253
 AliMultiplicityCorrection.cxx:254
 AliMultiplicityCorrection.cxx:255
 AliMultiplicityCorrection.cxx:256
 AliMultiplicityCorrection.cxx:257
 AliMultiplicityCorrection.cxx:258
 AliMultiplicityCorrection.cxx:259
 AliMultiplicityCorrection.cxx:260
 AliMultiplicityCorrection.cxx:261
 AliMultiplicityCorrection.cxx:262
 AliMultiplicityCorrection.cxx:263
 AliMultiplicityCorrection.cxx:264
 AliMultiplicityCorrection.cxx:265
 AliMultiplicityCorrection.cxx:266
 AliMultiplicityCorrection.cxx:267
 AliMultiplicityCorrection.cxx:268
 AliMultiplicityCorrection.cxx:269
 AliMultiplicityCorrection.cxx:270
 AliMultiplicityCorrection.cxx:271
 AliMultiplicityCorrection.cxx:272
 AliMultiplicityCorrection.cxx:273
 AliMultiplicityCorrection.cxx:274
 AliMultiplicityCorrection.cxx:275
 AliMultiplicityCorrection.cxx:276
 AliMultiplicityCorrection.cxx:277
 AliMultiplicityCorrection.cxx:278
 AliMultiplicityCorrection.cxx:279
 AliMultiplicityCorrection.cxx:280
 AliMultiplicityCorrection.cxx:281
 AliMultiplicityCorrection.cxx:282
 AliMultiplicityCorrection.cxx:283
 AliMultiplicityCorrection.cxx:284
 AliMultiplicityCorrection.cxx:285
 AliMultiplicityCorrection.cxx:286
 AliMultiplicityCorrection.cxx:287
 AliMultiplicityCorrection.cxx:288
 AliMultiplicityCorrection.cxx:289
 AliMultiplicityCorrection.cxx:290
 AliMultiplicityCorrection.cxx:291
 AliMultiplicityCorrection.cxx:292
 AliMultiplicityCorrection.cxx:293
 AliMultiplicityCorrection.cxx:294
 AliMultiplicityCorrection.cxx:295
 AliMultiplicityCorrection.cxx:296
 AliMultiplicityCorrection.cxx:297
 AliMultiplicityCorrection.cxx:298
 AliMultiplicityCorrection.cxx:299
 AliMultiplicityCorrection.cxx:300
 AliMultiplicityCorrection.cxx:301
 AliMultiplicityCorrection.cxx:302
 AliMultiplicityCorrection.cxx:303
 AliMultiplicityCorrection.cxx:304
 AliMultiplicityCorrection.cxx:305
 AliMultiplicityCorrection.cxx:306
 AliMultiplicityCorrection.cxx:307
 AliMultiplicityCorrection.cxx:308
 AliMultiplicityCorrection.cxx:309
 AliMultiplicityCorrection.cxx:310
 AliMultiplicityCorrection.cxx:311
 AliMultiplicityCorrection.cxx:312
 AliMultiplicityCorrection.cxx:313
 AliMultiplicityCorrection.cxx:314
 AliMultiplicityCorrection.cxx:315
 AliMultiplicityCorrection.cxx:316
 AliMultiplicityCorrection.cxx:317
 AliMultiplicityCorrection.cxx:318
 AliMultiplicityCorrection.cxx:319
 AliMultiplicityCorrection.cxx:320
 AliMultiplicityCorrection.cxx:321
 AliMultiplicityCorrection.cxx:322
 AliMultiplicityCorrection.cxx:323
 AliMultiplicityCorrection.cxx:324
 AliMultiplicityCorrection.cxx:325
 AliMultiplicityCorrection.cxx:326
 AliMultiplicityCorrection.cxx:327
 AliMultiplicityCorrection.cxx:328
 AliMultiplicityCorrection.cxx:329
 AliMultiplicityCorrection.cxx:330
 AliMultiplicityCorrection.cxx:331
 AliMultiplicityCorrection.cxx:332
 AliMultiplicityCorrection.cxx:333
 AliMultiplicityCorrection.cxx:334
 AliMultiplicityCorrection.cxx:335
 AliMultiplicityCorrection.cxx:336
 AliMultiplicityCorrection.cxx:337
 AliMultiplicityCorrection.cxx:338
 AliMultiplicityCorrection.cxx:339
 AliMultiplicityCorrection.cxx:340
 AliMultiplicityCorrection.cxx:341
 AliMultiplicityCorrection.cxx:342
 AliMultiplicityCorrection.cxx:343
 AliMultiplicityCorrection.cxx:344
 AliMultiplicityCorrection.cxx:345
 AliMultiplicityCorrection.cxx:346
 AliMultiplicityCorrection.cxx:347
 AliMultiplicityCorrection.cxx:348
 AliMultiplicityCorrection.cxx:349
 AliMultiplicityCorrection.cxx:350
 AliMultiplicityCorrection.cxx:351
 AliMultiplicityCorrection.cxx:352
 AliMultiplicityCorrection.cxx:353
 AliMultiplicityCorrection.cxx:354
 AliMultiplicityCorrection.cxx:355
 AliMultiplicityCorrection.cxx:356
 AliMultiplicityCorrection.cxx:357
 AliMultiplicityCorrection.cxx:358
 AliMultiplicityCorrection.cxx:359
 AliMultiplicityCorrection.cxx:360
 AliMultiplicityCorrection.cxx:361
 AliMultiplicityCorrection.cxx:362
 AliMultiplicityCorrection.cxx:363
 AliMultiplicityCorrection.cxx:364
 AliMultiplicityCorrection.cxx:365
 AliMultiplicityCorrection.cxx:366
 AliMultiplicityCorrection.cxx:367
 AliMultiplicityCorrection.cxx:368
 AliMultiplicityCorrection.cxx:369
 AliMultiplicityCorrection.cxx:370
 AliMultiplicityCorrection.cxx:371
 AliMultiplicityCorrection.cxx:372
 AliMultiplicityCorrection.cxx:373
 AliMultiplicityCorrection.cxx:374
 AliMultiplicityCorrection.cxx:375
 AliMultiplicityCorrection.cxx:376
 AliMultiplicityCorrection.cxx:377
 AliMultiplicityCorrection.cxx:378
 AliMultiplicityCorrection.cxx:379
 AliMultiplicityCorrection.cxx:380
 AliMultiplicityCorrection.cxx:381
 AliMultiplicityCorrection.cxx:382
 AliMultiplicityCorrection.cxx:383
 AliMultiplicityCorrection.cxx:384
 AliMultiplicityCorrection.cxx:385
 AliMultiplicityCorrection.cxx:386
 AliMultiplicityCorrection.cxx:387
 AliMultiplicityCorrection.cxx:388
 AliMultiplicityCorrection.cxx:389
 AliMultiplicityCorrection.cxx:390
 AliMultiplicityCorrection.cxx:391
 AliMultiplicityCorrection.cxx:392
 AliMultiplicityCorrection.cxx:393
 AliMultiplicityCorrection.cxx:394
 AliMultiplicityCorrection.cxx:395
 AliMultiplicityCorrection.cxx:396
 AliMultiplicityCorrection.cxx:397
 AliMultiplicityCorrection.cxx:398
 AliMultiplicityCorrection.cxx:399
 AliMultiplicityCorrection.cxx:400
 AliMultiplicityCorrection.cxx:401
 AliMultiplicityCorrection.cxx:402
 AliMultiplicityCorrection.cxx:403
 AliMultiplicityCorrection.cxx:404
 AliMultiplicityCorrection.cxx:405
 AliMultiplicityCorrection.cxx:406
 AliMultiplicityCorrection.cxx:407
 AliMultiplicityCorrection.cxx:408
 AliMultiplicityCorrection.cxx:409
 AliMultiplicityCorrection.cxx:410
 AliMultiplicityCorrection.cxx:411
 AliMultiplicityCorrection.cxx:412
 AliMultiplicityCorrection.cxx:413
 AliMultiplicityCorrection.cxx:414
 AliMultiplicityCorrection.cxx:415
 AliMultiplicityCorrection.cxx:416
 AliMultiplicityCorrection.cxx:417
 AliMultiplicityCorrection.cxx:418
 AliMultiplicityCorrection.cxx:419
 AliMultiplicityCorrection.cxx:420
 AliMultiplicityCorrection.cxx:421
 AliMultiplicityCorrection.cxx:422
 AliMultiplicityCorrection.cxx:423
 AliMultiplicityCorrection.cxx:424
 AliMultiplicityCorrection.cxx:425
 AliMultiplicityCorrection.cxx:426
 AliMultiplicityCorrection.cxx:427
 AliMultiplicityCorrection.cxx:428
 AliMultiplicityCorrection.cxx:429
 AliMultiplicityCorrection.cxx:430
 AliMultiplicityCorrection.cxx:431
 AliMultiplicityCorrection.cxx:432
 AliMultiplicityCorrection.cxx:433
 AliMultiplicityCorrection.cxx:434
 AliMultiplicityCorrection.cxx:435
 AliMultiplicityCorrection.cxx:436
 AliMultiplicityCorrection.cxx:437
 AliMultiplicityCorrection.cxx:438
 AliMultiplicityCorrection.cxx:439
 AliMultiplicityCorrection.cxx:440
 AliMultiplicityCorrection.cxx:441
 AliMultiplicityCorrection.cxx:442
 AliMultiplicityCorrection.cxx:443
 AliMultiplicityCorrection.cxx:444
 AliMultiplicityCorrection.cxx:445
 AliMultiplicityCorrection.cxx:446
 AliMultiplicityCorrection.cxx:447
 AliMultiplicityCorrection.cxx:448
 AliMultiplicityCorrection.cxx:449
 AliMultiplicityCorrection.cxx:450
 AliMultiplicityCorrection.cxx:451
 AliMultiplicityCorrection.cxx:452
 AliMultiplicityCorrection.cxx:453
 AliMultiplicityCorrection.cxx:454
 AliMultiplicityCorrection.cxx:455
 AliMultiplicityCorrection.cxx:456
 AliMultiplicityCorrection.cxx:457
 AliMultiplicityCorrection.cxx:458
 AliMultiplicityCorrection.cxx:459
 AliMultiplicityCorrection.cxx:460
 AliMultiplicityCorrection.cxx:461
 AliMultiplicityCorrection.cxx:462
 AliMultiplicityCorrection.cxx:463
 AliMultiplicityCorrection.cxx:464
 AliMultiplicityCorrection.cxx:465
 AliMultiplicityCorrection.cxx:466
 AliMultiplicityCorrection.cxx:467
 AliMultiplicityCorrection.cxx:468
 AliMultiplicityCorrection.cxx:469
 AliMultiplicityCorrection.cxx:470
 AliMultiplicityCorrection.cxx:471
 AliMultiplicityCorrection.cxx:472
 AliMultiplicityCorrection.cxx:473
 AliMultiplicityCorrection.cxx:474
 AliMultiplicityCorrection.cxx:475
 AliMultiplicityCorrection.cxx:476
 AliMultiplicityCorrection.cxx:477
 AliMultiplicityCorrection.cxx:478
 AliMultiplicityCorrection.cxx:479
 AliMultiplicityCorrection.cxx:480
 AliMultiplicityCorrection.cxx:481
 AliMultiplicityCorrection.cxx:482
 AliMultiplicityCorrection.cxx:483
 AliMultiplicityCorrection.cxx:484
 AliMultiplicityCorrection.cxx:485
 AliMultiplicityCorrection.cxx:486
 AliMultiplicityCorrection.cxx:487
 AliMultiplicityCorrection.cxx:488
 AliMultiplicityCorrection.cxx:489
 AliMultiplicityCorrection.cxx:490
 AliMultiplicityCorrection.cxx:491
 AliMultiplicityCorrection.cxx:492
 AliMultiplicityCorrection.cxx:493
 AliMultiplicityCorrection.cxx:494
 AliMultiplicityCorrection.cxx:495
 AliMultiplicityCorrection.cxx:496
 AliMultiplicityCorrection.cxx:497
 AliMultiplicityCorrection.cxx:498
 AliMultiplicityCorrection.cxx:499
 AliMultiplicityCorrection.cxx:500
 AliMultiplicityCorrection.cxx:501
 AliMultiplicityCorrection.cxx:502
 AliMultiplicityCorrection.cxx:503
 AliMultiplicityCorrection.cxx:504
 AliMultiplicityCorrection.cxx:505
 AliMultiplicityCorrection.cxx:506
 AliMultiplicityCorrection.cxx:507
 AliMultiplicityCorrection.cxx:508
 AliMultiplicityCorrection.cxx:509
 AliMultiplicityCorrection.cxx:510
 AliMultiplicityCorrection.cxx:511
 AliMultiplicityCorrection.cxx:512
 AliMultiplicityCorrection.cxx:513
 AliMultiplicityCorrection.cxx:514
 AliMultiplicityCorrection.cxx:515
 AliMultiplicityCorrection.cxx:516
 AliMultiplicityCorrection.cxx:517
 AliMultiplicityCorrection.cxx:518
 AliMultiplicityCorrection.cxx:519
 AliMultiplicityCorrection.cxx:520
 AliMultiplicityCorrection.cxx:521
 AliMultiplicityCorrection.cxx:522
 AliMultiplicityCorrection.cxx:523
 AliMultiplicityCorrection.cxx:524
 AliMultiplicityCorrection.cxx:525
 AliMultiplicityCorrection.cxx:526
 AliMultiplicityCorrection.cxx:527
 AliMultiplicityCorrection.cxx:528
 AliMultiplicityCorrection.cxx:529
 AliMultiplicityCorrection.cxx:530
 AliMultiplicityCorrection.cxx:531
 AliMultiplicityCorrection.cxx:532
 AliMultiplicityCorrection.cxx:533
 AliMultiplicityCorrection.cxx:534
 AliMultiplicityCorrection.cxx:535
 AliMultiplicityCorrection.cxx:536
 AliMultiplicityCorrection.cxx:537
 AliMultiplicityCorrection.cxx:538
 AliMultiplicityCorrection.cxx:539
 AliMultiplicityCorrection.cxx:540
 AliMultiplicityCorrection.cxx:541
 AliMultiplicityCorrection.cxx:542
 AliMultiplicityCorrection.cxx:543
 AliMultiplicityCorrection.cxx:544
 AliMultiplicityCorrection.cxx:545
 AliMultiplicityCorrection.cxx:546
 AliMultiplicityCorrection.cxx:547
 AliMultiplicityCorrection.cxx:548
 AliMultiplicityCorrection.cxx:549
 AliMultiplicityCorrection.cxx:550
 AliMultiplicityCorrection.cxx:551
 AliMultiplicityCorrection.cxx:552
 AliMultiplicityCorrection.cxx:553
 AliMultiplicityCorrection.cxx:554
 AliMultiplicityCorrection.cxx:555
 AliMultiplicityCorrection.cxx:556
 AliMultiplicityCorrection.cxx:557
 AliMultiplicityCorrection.cxx:558
 AliMultiplicityCorrection.cxx:559
 AliMultiplicityCorrection.cxx:560
 AliMultiplicityCorrection.cxx:561
 AliMultiplicityCorrection.cxx:562
 AliMultiplicityCorrection.cxx:563
 AliMultiplicityCorrection.cxx:564
 AliMultiplicityCorrection.cxx:565
 AliMultiplicityCorrection.cxx:566
 AliMultiplicityCorrection.cxx:567
 AliMultiplicityCorrection.cxx:568
 AliMultiplicityCorrection.cxx:569
 AliMultiplicityCorrection.cxx:570
 AliMultiplicityCorrection.cxx:571
 AliMultiplicityCorrection.cxx:572
 AliMultiplicityCorrection.cxx:573
 AliMultiplicityCorrection.cxx:574
 AliMultiplicityCorrection.cxx:575
 AliMultiplicityCorrection.cxx:576
 AliMultiplicityCorrection.cxx:577
 AliMultiplicityCorrection.cxx:578
 AliMultiplicityCorrection.cxx:579
 AliMultiplicityCorrection.cxx:580
 AliMultiplicityCorrection.cxx:581
 AliMultiplicityCorrection.cxx:582
 AliMultiplicityCorrection.cxx:583
 AliMultiplicityCorrection.cxx:584
 AliMultiplicityCorrection.cxx:585
 AliMultiplicityCorrection.cxx:586
 AliMultiplicityCorrection.cxx:587
 AliMultiplicityCorrection.cxx:588
 AliMultiplicityCorrection.cxx:589
 AliMultiplicityCorrection.cxx:590
 AliMultiplicityCorrection.cxx:591
 AliMultiplicityCorrection.cxx:592
 AliMultiplicityCorrection.cxx:593
 AliMultiplicityCorrection.cxx:594
 AliMultiplicityCorrection.cxx:595
 AliMultiplicityCorrection.cxx:596
 AliMultiplicityCorrection.cxx:597
 AliMultiplicityCorrection.cxx:598
 AliMultiplicityCorrection.cxx:599
 AliMultiplicityCorrection.cxx:600
 AliMultiplicityCorrection.cxx:601
 AliMultiplicityCorrection.cxx:602
 AliMultiplicityCorrection.cxx:603
 AliMultiplicityCorrection.cxx:604
 AliMultiplicityCorrection.cxx:605
 AliMultiplicityCorrection.cxx:606
 AliMultiplicityCorrection.cxx:607
 AliMultiplicityCorrection.cxx:608
 AliMultiplicityCorrection.cxx:609
 AliMultiplicityCorrection.cxx:610
 AliMultiplicityCorrection.cxx:611
 AliMultiplicityCorrection.cxx:612
 AliMultiplicityCorrection.cxx:613
 AliMultiplicityCorrection.cxx:614
 AliMultiplicityCorrection.cxx:615
 AliMultiplicityCorrection.cxx:616
 AliMultiplicityCorrection.cxx:617
 AliMultiplicityCorrection.cxx:618
 AliMultiplicityCorrection.cxx:619
 AliMultiplicityCorrection.cxx:620
 AliMultiplicityCorrection.cxx:621
 AliMultiplicityCorrection.cxx:622
 AliMultiplicityCorrection.cxx:623
 AliMultiplicityCorrection.cxx:624
 AliMultiplicityCorrection.cxx:625
 AliMultiplicityCorrection.cxx:626
 AliMultiplicityCorrection.cxx:627
 AliMultiplicityCorrection.cxx:628
 AliMultiplicityCorrection.cxx:629
 AliMultiplicityCorrection.cxx:630
 AliMultiplicityCorrection.cxx:631
 AliMultiplicityCorrection.cxx:632
 AliMultiplicityCorrection.cxx:633
 AliMultiplicityCorrection.cxx:634
 AliMultiplicityCorrection.cxx:635
 AliMultiplicityCorrection.cxx:636
 AliMultiplicityCorrection.cxx:637
 AliMultiplicityCorrection.cxx:638
 AliMultiplicityCorrection.cxx:639
 AliMultiplicityCorrection.cxx:640
 AliMultiplicityCorrection.cxx:641
 AliMultiplicityCorrection.cxx:642
 AliMultiplicityCorrection.cxx:643
 AliMultiplicityCorrection.cxx:644
 AliMultiplicityCorrection.cxx:645
 AliMultiplicityCorrection.cxx:646
 AliMultiplicityCorrection.cxx:647
 AliMultiplicityCorrection.cxx:648
 AliMultiplicityCorrection.cxx:649
 AliMultiplicityCorrection.cxx:650
 AliMultiplicityCorrection.cxx:651
 AliMultiplicityCorrection.cxx:652
 AliMultiplicityCorrection.cxx:653
 AliMultiplicityCorrection.cxx:654
 AliMultiplicityCorrection.cxx:655
 AliMultiplicityCorrection.cxx:656
 AliMultiplicityCorrection.cxx:657
 AliMultiplicityCorrection.cxx:658
 AliMultiplicityCorrection.cxx:659
 AliMultiplicityCorrection.cxx:660
 AliMultiplicityCorrection.cxx:661
 AliMultiplicityCorrection.cxx:662
 AliMultiplicityCorrection.cxx:663
 AliMultiplicityCorrection.cxx:664
 AliMultiplicityCorrection.cxx:665
 AliMultiplicityCorrection.cxx:666
 AliMultiplicityCorrection.cxx:667
 AliMultiplicityCorrection.cxx:668
 AliMultiplicityCorrection.cxx:669
 AliMultiplicityCorrection.cxx:670
 AliMultiplicityCorrection.cxx:671
 AliMultiplicityCorrection.cxx:672
 AliMultiplicityCorrection.cxx:673
 AliMultiplicityCorrection.cxx:674
 AliMultiplicityCorrection.cxx:675
 AliMultiplicityCorrection.cxx:676
 AliMultiplicityCorrection.cxx:677
 AliMultiplicityCorrection.cxx:678
 AliMultiplicityCorrection.cxx:679
 AliMultiplicityCorrection.cxx:680
 AliMultiplicityCorrection.cxx:681
 AliMultiplicityCorrection.cxx:682
 AliMultiplicityCorrection.cxx:683
 AliMultiplicityCorrection.cxx:684
 AliMultiplicityCorrection.cxx:685
 AliMultiplicityCorrection.cxx:686
 AliMultiplicityCorrection.cxx:687
 AliMultiplicityCorrection.cxx:688
 AliMultiplicityCorrection.cxx:689
 AliMultiplicityCorrection.cxx:690
 AliMultiplicityCorrection.cxx:691
 AliMultiplicityCorrection.cxx:692
 AliMultiplicityCorrection.cxx:693
 AliMultiplicityCorrection.cxx:694
 AliMultiplicityCorrection.cxx:695
 AliMultiplicityCorrection.cxx:696
 AliMultiplicityCorrection.cxx:697
 AliMultiplicityCorrection.cxx:698
 AliMultiplicityCorrection.cxx:699
 AliMultiplicityCorrection.cxx:700
 AliMultiplicityCorrection.cxx:701
 AliMultiplicityCorrection.cxx:702
 AliMultiplicityCorrection.cxx:703
 AliMultiplicityCorrection.cxx:704
 AliMultiplicityCorrection.cxx:705
 AliMultiplicityCorrection.cxx:706
 AliMultiplicityCorrection.cxx:707
 AliMultiplicityCorrection.cxx:708
 AliMultiplicityCorrection.cxx:709
 AliMultiplicityCorrection.cxx:710
 AliMultiplicityCorrection.cxx:711
 AliMultiplicityCorrection.cxx:712
 AliMultiplicityCorrection.cxx:713
 AliMultiplicityCorrection.cxx:714
 AliMultiplicityCorrection.cxx:715
 AliMultiplicityCorrection.cxx:716
 AliMultiplicityCorrection.cxx:717
 AliMultiplicityCorrection.cxx:718
 AliMultiplicityCorrection.cxx:719
 AliMultiplicityCorrection.cxx:720
 AliMultiplicityCorrection.cxx:721
 AliMultiplicityCorrection.cxx:722
 AliMultiplicityCorrection.cxx:723
 AliMultiplicityCorrection.cxx:724
 AliMultiplicityCorrection.cxx:725
 AliMultiplicityCorrection.cxx:726
 AliMultiplicityCorrection.cxx:727
 AliMultiplicityCorrection.cxx:728
 AliMultiplicityCorrection.cxx:729
 AliMultiplicityCorrection.cxx:730
 AliMultiplicityCorrection.cxx:731
 AliMultiplicityCorrection.cxx:732
 AliMultiplicityCorrection.cxx:733
 AliMultiplicityCorrection.cxx:734
 AliMultiplicityCorrection.cxx:735
 AliMultiplicityCorrection.cxx:736
 AliMultiplicityCorrection.cxx:737
 AliMultiplicityCorrection.cxx:738
 AliMultiplicityCorrection.cxx:739
 AliMultiplicityCorrection.cxx:740
 AliMultiplicityCorrection.cxx:741
 AliMultiplicityCorrection.cxx:742
 AliMultiplicityCorrection.cxx:743
 AliMultiplicityCorrection.cxx:744
 AliMultiplicityCorrection.cxx:745
 AliMultiplicityCorrection.cxx:746
 AliMultiplicityCorrection.cxx:747
 AliMultiplicityCorrection.cxx:748
 AliMultiplicityCorrection.cxx:749
 AliMultiplicityCorrection.cxx:750
 AliMultiplicityCorrection.cxx:751
 AliMultiplicityCorrection.cxx:752
 AliMultiplicityCorrection.cxx:753
 AliMultiplicityCorrection.cxx:754
 AliMultiplicityCorrection.cxx:755
 AliMultiplicityCorrection.cxx:756
 AliMultiplicityCorrection.cxx:757
 AliMultiplicityCorrection.cxx:758
 AliMultiplicityCorrection.cxx:759
 AliMultiplicityCorrection.cxx:760
 AliMultiplicityCorrection.cxx:761
 AliMultiplicityCorrection.cxx:762
 AliMultiplicityCorrection.cxx:763
 AliMultiplicityCorrection.cxx:764
 AliMultiplicityCorrection.cxx:765
 AliMultiplicityCorrection.cxx:766
 AliMultiplicityCorrection.cxx:767
 AliMultiplicityCorrection.cxx:768
 AliMultiplicityCorrection.cxx:769
 AliMultiplicityCorrection.cxx:770
 AliMultiplicityCorrection.cxx:771
 AliMultiplicityCorrection.cxx:772
 AliMultiplicityCorrection.cxx:773
 AliMultiplicityCorrection.cxx:774
 AliMultiplicityCorrection.cxx:775
 AliMultiplicityCorrection.cxx:776
 AliMultiplicityCorrection.cxx:777
 AliMultiplicityCorrection.cxx:778
 AliMultiplicityCorrection.cxx:779
 AliMultiplicityCorrection.cxx:780
 AliMultiplicityCorrection.cxx:781
 AliMultiplicityCorrection.cxx:782
 AliMultiplicityCorrection.cxx:783
 AliMultiplicityCorrection.cxx:784
 AliMultiplicityCorrection.cxx:785
 AliMultiplicityCorrection.cxx:786
 AliMultiplicityCorrection.cxx:787
 AliMultiplicityCorrection.cxx:788
 AliMultiplicityCorrection.cxx:789
 AliMultiplicityCorrection.cxx:790
 AliMultiplicityCorrection.cxx:791
 AliMultiplicityCorrection.cxx:792
 AliMultiplicityCorrection.cxx:793
 AliMultiplicityCorrection.cxx:794
 AliMultiplicityCorrection.cxx:795
 AliMultiplicityCorrection.cxx:796
 AliMultiplicityCorrection.cxx:797
 AliMultiplicityCorrection.cxx:798
 AliMultiplicityCorrection.cxx:799
 AliMultiplicityCorrection.cxx:800
 AliMultiplicityCorrection.cxx:801
 AliMultiplicityCorrection.cxx:802
 AliMultiplicityCorrection.cxx:803
 AliMultiplicityCorrection.cxx:804
 AliMultiplicityCorrection.cxx:805
 AliMultiplicityCorrection.cxx:806
 AliMultiplicityCorrection.cxx:807
 AliMultiplicityCorrection.cxx:808
 AliMultiplicityCorrection.cxx:809
 AliMultiplicityCorrection.cxx:810
 AliMultiplicityCorrection.cxx:811
 AliMultiplicityCorrection.cxx:812
 AliMultiplicityCorrection.cxx:813
 AliMultiplicityCorrection.cxx:814
 AliMultiplicityCorrection.cxx:815
 AliMultiplicityCorrection.cxx:816
 AliMultiplicityCorrection.cxx:817
 AliMultiplicityCorrection.cxx:818
 AliMultiplicityCorrection.cxx:819
 AliMultiplicityCorrection.cxx:820
 AliMultiplicityCorrection.cxx:821
 AliMultiplicityCorrection.cxx:822
 AliMultiplicityCorrection.cxx:823
 AliMultiplicityCorrection.cxx:824
 AliMultiplicityCorrection.cxx:825
 AliMultiplicityCorrection.cxx:826
 AliMultiplicityCorrection.cxx:827
 AliMultiplicityCorrection.cxx:828
 AliMultiplicityCorrection.cxx:829
 AliMultiplicityCorrection.cxx:830
 AliMultiplicityCorrection.cxx:831
 AliMultiplicityCorrection.cxx:832
 AliMultiplicityCorrection.cxx:833
 AliMultiplicityCorrection.cxx:834
 AliMultiplicityCorrection.cxx:835
 AliMultiplicityCorrection.cxx:836
 AliMultiplicityCorrection.cxx:837
 AliMultiplicityCorrection.cxx:838
 AliMultiplicityCorrection.cxx:839
 AliMultiplicityCorrection.cxx:840
 AliMultiplicityCorrection.cxx:841
 AliMultiplicityCorrection.cxx:842
 AliMultiplicityCorrection.cxx:843
 AliMultiplicityCorrection.cxx:844
 AliMultiplicityCorrection.cxx:845
 AliMultiplicityCorrection.cxx:846
 AliMultiplicityCorrection.cxx:847
 AliMultiplicityCorrection.cxx:848
 AliMultiplicityCorrection.cxx:849
 AliMultiplicityCorrection.cxx:850
 AliMultiplicityCorrection.cxx:851
 AliMultiplicityCorrection.cxx:852
 AliMultiplicityCorrection.cxx:853
 AliMultiplicityCorrection.cxx:854
 AliMultiplicityCorrection.cxx:855
 AliMultiplicityCorrection.cxx:856
 AliMultiplicityCorrection.cxx:857
 AliMultiplicityCorrection.cxx:858
 AliMultiplicityCorrection.cxx:859
 AliMultiplicityCorrection.cxx:860
 AliMultiplicityCorrection.cxx:861
 AliMultiplicityCorrection.cxx:862
 AliMultiplicityCorrection.cxx:863
 AliMultiplicityCorrection.cxx:864
 AliMultiplicityCorrection.cxx:865
 AliMultiplicityCorrection.cxx:866
 AliMultiplicityCorrection.cxx:867
 AliMultiplicityCorrection.cxx:868
 AliMultiplicityCorrection.cxx:869
 AliMultiplicityCorrection.cxx:870
 AliMultiplicityCorrection.cxx:871
 AliMultiplicityCorrection.cxx:872
 AliMultiplicityCorrection.cxx:873
 AliMultiplicityCorrection.cxx:874
 AliMultiplicityCorrection.cxx:875
 AliMultiplicityCorrection.cxx:876
 AliMultiplicityCorrection.cxx:877
 AliMultiplicityCorrection.cxx:878
 AliMultiplicityCorrection.cxx:879
 AliMultiplicityCorrection.cxx:880
 AliMultiplicityCorrection.cxx:881
 AliMultiplicityCorrection.cxx:882
 AliMultiplicityCorrection.cxx:883
 AliMultiplicityCorrection.cxx:884
 AliMultiplicityCorrection.cxx:885
 AliMultiplicityCorrection.cxx:886
 AliMultiplicityCorrection.cxx:887
 AliMultiplicityCorrection.cxx:888
 AliMultiplicityCorrection.cxx:889
 AliMultiplicityCorrection.cxx:890
 AliMultiplicityCorrection.cxx:891
 AliMultiplicityCorrection.cxx:892
 AliMultiplicityCorrection.cxx:893
 AliMultiplicityCorrection.cxx:894
 AliMultiplicityCorrection.cxx:895
 AliMultiplicityCorrection.cxx:896
 AliMultiplicityCorrection.cxx:897
 AliMultiplicityCorrection.cxx:898
 AliMultiplicityCorrection.cxx:899
 AliMultiplicityCorrection.cxx:900
 AliMultiplicityCorrection.cxx:901
 AliMultiplicityCorrection.cxx:902
 AliMultiplicityCorrection.cxx:903
 AliMultiplicityCorrection.cxx:904
 AliMultiplicityCorrection.cxx:905
 AliMultiplicityCorrection.cxx:906
 AliMultiplicityCorrection.cxx:907
 AliMultiplicityCorrection.cxx:908
 AliMultiplicityCorrection.cxx:909
 AliMultiplicityCorrection.cxx:910
 AliMultiplicityCorrection.cxx:911
 AliMultiplicityCorrection.cxx:912
 AliMultiplicityCorrection.cxx:913
 AliMultiplicityCorrection.cxx:914
 AliMultiplicityCorrection.cxx:915
 AliMultiplicityCorrection.cxx:916
 AliMultiplicityCorrection.cxx:917
 AliMultiplicityCorrection.cxx:918
 AliMultiplicityCorrection.cxx:919
 AliMultiplicityCorrection.cxx:920
 AliMultiplicityCorrection.cxx:921
 AliMultiplicityCorrection.cxx:922
 AliMultiplicityCorrection.cxx:923
 AliMultiplicityCorrection.cxx:924
 AliMultiplicityCorrection.cxx:925
 AliMultiplicityCorrection.cxx:926
 AliMultiplicityCorrection.cxx:927
 AliMultiplicityCorrection.cxx:928
 AliMultiplicityCorrection.cxx:929
 AliMultiplicityCorrection.cxx:930
 AliMultiplicityCorrection.cxx:931
 AliMultiplicityCorrection.cxx:932
 AliMultiplicityCorrection.cxx:933
 AliMultiplicityCorrection.cxx:934
 AliMultiplicityCorrection.cxx:935
 AliMultiplicityCorrection.cxx:936
 AliMultiplicityCorrection.cxx:937
 AliMultiplicityCorrection.cxx:938
 AliMultiplicityCorrection.cxx:939
 AliMultiplicityCorrection.cxx:940
 AliMultiplicityCorrection.cxx:941
 AliMultiplicityCorrection.cxx:942
 AliMultiplicityCorrection.cxx:943
 AliMultiplicityCorrection.cxx:944
 AliMultiplicityCorrection.cxx:945
 AliMultiplicityCorrection.cxx:946
 AliMultiplicityCorrection.cxx:947
 AliMultiplicityCorrection.cxx:948
 AliMultiplicityCorrection.cxx:949
 AliMultiplicityCorrection.cxx:950
 AliMultiplicityCorrection.cxx:951
 AliMultiplicityCorrection.cxx:952
 AliMultiplicityCorrection.cxx:953
 AliMultiplicityCorrection.cxx:954
 AliMultiplicityCorrection.cxx:955
 AliMultiplicityCorrection.cxx:956
 AliMultiplicityCorrection.cxx:957
 AliMultiplicityCorrection.cxx:958
 AliMultiplicityCorrection.cxx:959
 AliMultiplicityCorrection.cxx:960
 AliMultiplicityCorrection.cxx:961
 AliMultiplicityCorrection.cxx:962
 AliMultiplicityCorrection.cxx:963
 AliMultiplicityCorrection.cxx:964
 AliMultiplicityCorrection.cxx:965
 AliMultiplicityCorrection.cxx:966
 AliMultiplicityCorrection.cxx:967
 AliMultiplicityCorrection.cxx:968
 AliMultiplicityCorrection.cxx:969
 AliMultiplicityCorrection.cxx:970
 AliMultiplicityCorrection.cxx:971
 AliMultiplicityCorrection.cxx:972
 AliMultiplicityCorrection.cxx:973
 AliMultiplicityCorrection.cxx:974
 AliMultiplicityCorrection.cxx:975
 AliMultiplicityCorrection.cxx:976
 AliMultiplicityCorrection.cxx:977
 AliMultiplicityCorrection.cxx:978
 AliMultiplicityCorrection.cxx:979
 AliMultiplicityCorrection.cxx:980
 AliMultiplicityCorrection.cxx:981
 AliMultiplicityCorrection.cxx:982
 AliMultiplicityCorrection.cxx:983
 AliMultiplicityCorrection.cxx:984
 AliMultiplicityCorrection.cxx:985
 AliMultiplicityCorrection.cxx:986
 AliMultiplicityCorrection.cxx:987
 AliMultiplicityCorrection.cxx:988
 AliMultiplicityCorrection.cxx:989
 AliMultiplicityCorrection.cxx:990
 AliMultiplicityCorrection.cxx:991
 AliMultiplicityCorrection.cxx:992
 AliMultiplicityCorrection.cxx:993
 AliMultiplicityCorrection.cxx:994
 AliMultiplicityCorrection.cxx:995
 AliMultiplicityCorrection.cxx:996
 AliMultiplicityCorrection.cxx:997
 AliMultiplicityCorrection.cxx:998
 AliMultiplicityCorrection.cxx:999
 AliMultiplicityCorrection.cxx:1000
 AliMultiplicityCorrection.cxx:1001
 AliMultiplicityCorrection.cxx:1002
 AliMultiplicityCorrection.cxx:1003
 AliMultiplicityCorrection.cxx:1004
 AliMultiplicityCorrection.cxx:1005
 AliMultiplicityCorrection.cxx:1006
 AliMultiplicityCorrection.cxx:1007
 AliMultiplicityCorrection.cxx:1008
 AliMultiplicityCorrection.cxx:1009
 AliMultiplicityCorrection.cxx:1010
 AliMultiplicityCorrection.cxx:1011
 AliMultiplicityCorrection.cxx:1012
 AliMultiplicityCorrection.cxx:1013
 AliMultiplicityCorrection.cxx:1014
 AliMultiplicityCorrection.cxx:1015
 AliMultiplicityCorrection.cxx:1016
 AliMultiplicityCorrection.cxx:1017
 AliMultiplicityCorrection.cxx:1018
 AliMultiplicityCorrection.cxx:1019
 AliMultiplicityCorrection.cxx:1020
 AliMultiplicityCorrection.cxx:1021
 AliMultiplicityCorrection.cxx:1022
 AliMultiplicityCorrection.cxx:1023
 AliMultiplicityCorrection.cxx:1024
 AliMultiplicityCorrection.cxx:1025
 AliMultiplicityCorrection.cxx:1026
 AliMultiplicityCorrection.cxx:1027
 AliMultiplicityCorrection.cxx:1028
 AliMultiplicityCorrection.cxx:1029
 AliMultiplicityCorrection.cxx:1030
 AliMultiplicityCorrection.cxx:1031
 AliMultiplicityCorrection.cxx:1032
 AliMultiplicityCorrection.cxx:1033
 AliMultiplicityCorrection.cxx:1034
 AliMultiplicityCorrection.cxx:1035
 AliMultiplicityCorrection.cxx:1036
 AliMultiplicityCorrection.cxx:1037
 AliMultiplicityCorrection.cxx:1038
 AliMultiplicityCorrection.cxx:1039
 AliMultiplicityCorrection.cxx:1040
 AliMultiplicityCorrection.cxx:1041
 AliMultiplicityCorrection.cxx:1042
 AliMultiplicityCorrection.cxx:1043
 AliMultiplicityCorrection.cxx:1044
 AliMultiplicityCorrection.cxx:1045
 AliMultiplicityCorrection.cxx:1046
 AliMultiplicityCorrection.cxx:1047
 AliMultiplicityCorrection.cxx:1048
 AliMultiplicityCorrection.cxx:1049
 AliMultiplicityCorrection.cxx:1050
 AliMultiplicityCorrection.cxx:1051
 AliMultiplicityCorrection.cxx:1052
 AliMultiplicityCorrection.cxx:1053
 AliMultiplicityCorrection.cxx:1054
 AliMultiplicityCorrection.cxx:1055
 AliMultiplicityCorrection.cxx:1056
 AliMultiplicityCorrection.cxx:1057
 AliMultiplicityCorrection.cxx:1058
 AliMultiplicityCorrection.cxx:1059
 AliMultiplicityCorrection.cxx:1060
 AliMultiplicityCorrection.cxx:1061
 AliMultiplicityCorrection.cxx:1062
 AliMultiplicityCorrection.cxx:1063
 AliMultiplicityCorrection.cxx:1064
 AliMultiplicityCorrection.cxx:1065
 AliMultiplicityCorrection.cxx:1066
 AliMultiplicityCorrection.cxx:1067
 AliMultiplicityCorrection.cxx:1068
 AliMultiplicityCorrection.cxx:1069
 AliMultiplicityCorrection.cxx:1070
 AliMultiplicityCorrection.cxx:1071
 AliMultiplicityCorrection.cxx:1072
 AliMultiplicityCorrection.cxx:1073
 AliMultiplicityCorrection.cxx:1074
 AliMultiplicityCorrection.cxx:1075
 AliMultiplicityCorrection.cxx:1076
 AliMultiplicityCorrection.cxx:1077
 AliMultiplicityCorrection.cxx:1078
 AliMultiplicityCorrection.cxx:1079
 AliMultiplicityCorrection.cxx:1080
 AliMultiplicityCorrection.cxx:1081
 AliMultiplicityCorrection.cxx:1082
 AliMultiplicityCorrection.cxx:1083
 AliMultiplicityCorrection.cxx:1084
 AliMultiplicityCorrection.cxx:1085
 AliMultiplicityCorrection.cxx:1086
 AliMultiplicityCorrection.cxx:1087
 AliMultiplicityCorrection.cxx:1088
 AliMultiplicityCorrection.cxx:1089
 AliMultiplicityCorrection.cxx:1090
 AliMultiplicityCorrection.cxx:1091
 AliMultiplicityCorrection.cxx:1092
 AliMultiplicityCorrection.cxx:1093
 AliMultiplicityCorrection.cxx:1094
 AliMultiplicityCorrection.cxx:1095
 AliMultiplicityCorrection.cxx:1096
 AliMultiplicityCorrection.cxx:1097
 AliMultiplicityCorrection.cxx:1098
 AliMultiplicityCorrection.cxx:1099
 AliMultiplicityCorrection.cxx:1100
 AliMultiplicityCorrection.cxx:1101
 AliMultiplicityCorrection.cxx:1102
 AliMultiplicityCorrection.cxx:1103
 AliMultiplicityCorrection.cxx:1104
 AliMultiplicityCorrection.cxx:1105
 AliMultiplicityCorrection.cxx:1106
 AliMultiplicityCorrection.cxx:1107
 AliMultiplicityCorrection.cxx:1108
 AliMultiplicityCorrection.cxx:1109
 AliMultiplicityCorrection.cxx:1110
 AliMultiplicityCorrection.cxx:1111
 AliMultiplicityCorrection.cxx:1112
 AliMultiplicityCorrection.cxx:1113
 AliMultiplicityCorrection.cxx:1114
 AliMultiplicityCorrection.cxx:1115
 AliMultiplicityCorrection.cxx:1116
 AliMultiplicityCorrection.cxx:1117
 AliMultiplicityCorrection.cxx:1118
 AliMultiplicityCorrection.cxx:1119
 AliMultiplicityCorrection.cxx:1120
 AliMultiplicityCorrection.cxx:1121
 AliMultiplicityCorrection.cxx:1122
 AliMultiplicityCorrection.cxx:1123
 AliMultiplicityCorrection.cxx:1124
 AliMultiplicityCorrection.cxx:1125
 AliMultiplicityCorrection.cxx:1126
 AliMultiplicityCorrection.cxx:1127
 AliMultiplicityCorrection.cxx:1128
 AliMultiplicityCorrection.cxx:1129
 AliMultiplicityCorrection.cxx:1130
 AliMultiplicityCorrection.cxx:1131
 AliMultiplicityCorrection.cxx:1132
 AliMultiplicityCorrection.cxx:1133
 AliMultiplicityCorrection.cxx:1134
 AliMultiplicityCorrection.cxx:1135
 AliMultiplicityCorrection.cxx:1136
 AliMultiplicityCorrection.cxx:1137
 AliMultiplicityCorrection.cxx:1138
 AliMultiplicityCorrection.cxx:1139
 AliMultiplicityCorrection.cxx:1140
 AliMultiplicityCorrection.cxx:1141
 AliMultiplicityCorrection.cxx:1142
 AliMultiplicityCorrection.cxx:1143
 AliMultiplicityCorrection.cxx:1144
 AliMultiplicityCorrection.cxx:1145
 AliMultiplicityCorrection.cxx:1146
 AliMultiplicityCorrection.cxx:1147
 AliMultiplicityCorrection.cxx:1148
 AliMultiplicityCorrection.cxx:1149
 AliMultiplicityCorrection.cxx:1150
 AliMultiplicityCorrection.cxx:1151
 AliMultiplicityCorrection.cxx:1152
 AliMultiplicityCorrection.cxx:1153
 AliMultiplicityCorrection.cxx:1154
 AliMultiplicityCorrection.cxx:1155
 AliMultiplicityCorrection.cxx:1156
 AliMultiplicityCorrection.cxx:1157
 AliMultiplicityCorrection.cxx:1158
 AliMultiplicityCorrection.cxx:1159
 AliMultiplicityCorrection.cxx:1160
 AliMultiplicityCorrection.cxx:1161
 AliMultiplicityCorrection.cxx:1162
 AliMultiplicityCorrection.cxx:1163
 AliMultiplicityCorrection.cxx:1164
 AliMultiplicityCorrection.cxx:1165
 AliMultiplicityCorrection.cxx:1166
 AliMultiplicityCorrection.cxx:1167
 AliMultiplicityCorrection.cxx:1168
 AliMultiplicityCorrection.cxx:1169
 AliMultiplicityCorrection.cxx:1170
 AliMultiplicityCorrection.cxx:1171
 AliMultiplicityCorrection.cxx:1172
 AliMultiplicityCorrection.cxx:1173
 AliMultiplicityCorrection.cxx:1174
 AliMultiplicityCorrection.cxx:1175
 AliMultiplicityCorrection.cxx:1176
 AliMultiplicityCorrection.cxx:1177
 AliMultiplicityCorrection.cxx:1178
 AliMultiplicityCorrection.cxx:1179
 AliMultiplicityCorrection.cxx:1180
 AliMultiplicityCorrection.cxx:1181
 AliMultiplicityCorrection.cxx:1182
 AliMultiplicityCorrection.cxx:1183
 AliMultiplicityCorrection.cxx:1184
 AliMultiplicityCorrection.cxx:1185
 AliMultiplicityCorrection.cxx:1186
 AliMultiplicityCorrection.cxx:1187
 AliMultiplicityCorrection.cxx:1188
 AliMultiplicityCorrection.cxx:1189
 AliMultiplicityCorrection.cxx:1190
 AliMultiplicityCorrection.cxx:1191
 AliMultiplicityCorrection.cxx:1192
 AliMultiplicityCorrection.cxx:1193
 AliMultiplicityCorrection.cxx:1194
 AliMultiplicityCorrection.cxx:1195
 AliMultiplicityCorrection.cxx:1196
 AliMultiplicityCorrection.cxx:1197
 AliMultiplicityCorrection.cxx:1198
 AliMultiplicityCorrection.cxx:1199
 AliMultiplicityCorrection.cxx:1200
 AliMultiplicityCorrection.cxx:1201
 AliMultiplicityCorrection.cxx:1202
 AliMultiplicityCorrection.cxx:1203
 AliMultiplicityCorrection.cxx:1204
 AliMultiplicityCorrection.cxx:1205
 AliMultiplicityCorrection.cxx:1206
 AliMultiplicityCorrection.cxx:1207
 AliMultiplicityCorrection.cxx:1208
 AliMultiplicityCorrection.cxx:1209
 AliMultiplicityCorrection.cxx:1210
 AliMultiplicityCorrection.cxx:1211
 AliMultiplicityCorrection.cxx:1212
 AliMultiplicityCorrection.cxx:1213
 AliMultiplicityCorrection.cxx:1214
 AliMultiplicityCorrection.cxx:1215
 AliMultiplicityCorrection.cxx:1216
 AliMultiplicityCorrection.cxx:1217
 AliMultiplicityCorrection.cxx:1218
 AliMultiplicityCorrection.cxx:1219
 AliMultiplicityCorrection.cxx:1220
 AliMultiplicityCorrection.cxx:1221
 AliMultiplicityCorrection.cxx:1222
 AliMultiplicityCorrection.cxx:1223
 AliMultiplicityCorrection.cxx:1224
 AliMultiplicityCorrection.cxx:1225
 AliMultiplicityCorrection.cxx:1226
 AliMultiplicityCorrection.cxx:1227
 AliMultiplicityCorrection.cxx:1228
 AliMultiplicityCorrection.cxx:1229
 AliMultiplicityCorrection.cxx:1230
 AliMultiplicityCorrection.cxx:1231
 AliMultiplicityCorrection.cxx:1232
 AliMultiplicityCorrection.cxx:1233
 AliMultiplicityCorrection.cxx:1234
 AliMultiplicityCorrection.cxx:1235
 AliMultiplicityCorrection.cxx:1236
 AliMultiplicityCorrection.cxx:1237
 AliMultiplicityCorrection.cxx:1238
 AliMultiplicityCorrection.cxx:1239
 AliMultiplicityCorrection.cxx:1240
 AliMultiplicityCorrection.cxx:1241
 AliMultiplicityCorrection.cxx:1242
 AliMultiplicityCorrection.cxx:1243
 AliMultiplicityCorrection.cxx:1244
 AliMultiplicityCorrection.cxx:1245
 AliMultiplicityCorrection.cxx:1246
 AliMultiplicityCorrection.cxx:1247
 AliMultiplicityCorrection.cxx:1248
 AliMultiplicityCorrection.cxx:1249
 AliMultiplicityCorrection.cxx:1250
 AliMultiplicityCorrection.cxx:1251
 AliMultiplicityCorrection.cxx:1252
 AliMultiplicityCorrection.cxx:1253
 AliMultiplicityCorrection.cxx:1254
 AliMultiplicityCorrection.cxx:1255
 AliMultiplicityCorrection.cxx:1256
 AliMultiplicityCorrection.cxx:1257
 AliMultiplicityCorrection.cxx:1258
 AliMultiplicityCorrection.cxx:1259
 AliMultiplicityCorrection.cxx:1260
 AliMultiplicityCorrection.cxx:1261
 AliMultiplicityCorrection.cxx:1262
 AliMultiplicityCorrection.cxx:1263
 AliMultiplicityCorrection.cxx:1264
 AliMultiplicityCorrection.cxx:1265
 AliMultiplicityCorrection.cxx:1266
 AliMultiplicityCorrection.cxx:1267
 AliMultiplicityCorrection.cxx:1268
 AliMultiplicityCorrection.cxx:1269
 AliMultiplicityCorrection.cxx:1270
 AliMultiplicityCorrection.cxx:1271
 AliMultiplicityCorrection.cxx:1272
 AliMultiplicityCorrection.cxx:1273
 AliMultiplicityCorrection.cxx:1274
 AliMultiplicityCorrection.cxx:1275
 AliMultiplicityCorrection.cxx:1276
 AliMultiplicityCorrection.cxx:1277
 AliMultiplicityCorrection.cxx:1278
 AliMultiplicityCorrection.cxx:1279
 AliMultiplicityCorrection.cxx:1280
 AliMultiplicityCorrection.cxx:1281
 AliMultiplicityCorrection.cxx:1282
 AliMultiplicityCorrection.cxx:1283
 AliMultiplicityCorrection.cxx:1284
 AliMultiplicityCorrection.cxx:1285
 AliMultiplicityCorrection.cxx:1286
 AliMultiplicityCorrection.cxx:1287
 AliMultiplicityCorrection.cxx:1288
 AliMultiplicityCorrection.cxx:1289
 AliMultiplicityCorrection.cxx:1290
 AliMultiplicityCorrection.cxx:1291
 AliMultiplicityCorrection.cxx:1292
 AliMultiplicityCorrection.cxx:1293
 AliMultiplicityCorrection.cxx:1294
 AliMultiplicityCorrection.cxx:1295
 AliMultiplicityCorrection.cxx:1296
 AliMultiplicityCorrection.cxx:1297
 AliMultiplicityCorrection.cxx:1298
 AliMultiplicityCorrection.cxx:1299
 AliMultiplicityCorrection.cxx:1300
 AliMultiplicityCorrection.cxx:1301
 AliMultiplicityCorrection.cxx:1302
 AliMultiplicityCorrection.cxx:1303
 AliMultiplicityCorrection.cxx:1304
 AliMultiplicityCorrection.cxx:1305
 AliMultiplicityCorrection.cxx:1306
 AliMultiplicityCorrection.cxx:1307
 AliMultiplicityCorrection.cxx:1308
 AliMultiplicityCorrection.cxx:1309
 AliMultiplicityCorrection.cxx:1310
 AliMultiplicityCorrection.cxx:1311
 AliMultiplicityCorrection.cxx:1312
 AliMultiplicityCorrection.cxx:1313
 AliMultiplicityCorrection.cxx:1314
 AliMultiplicityCorrection.cxx:1315
 AliMultiplicityCorrection.cxx:1316
 AliMultiplicityCorrection.cxx:1317
 AliMultiplicityCorrection.cxx:1318
 AliMultiplicityCorrection.cxx:1319
 AliMultiplicityCorrection.cxx:1320
 AliMultiplicityCorrection.cxx:1321
 AliMultiplicityCorrection.cxx:1322
 AliMultiplicityCorrection.cxx:1323
 AliMultiplicityCorrection.cxx:1324
 AliMultiplicityCorrection.cxx:1325
 AliMultiplicityCorrection.cxx:1326
 AliMultiplicityCorrection.cxx:1327
 AliMultiplicityCorrection.cxx:1328
 AliMultiplicityCorrection.cxx:1329
 AliMultiplicityCorrection.cxx:1330
 AliMultiplicityCorrection.cxx:1331
 AliMultiplicityCorrection.cxx:1332
 AliMultiplicityCorrection.cxx:1333
 AliMultiplicityCorrection.cxx:1334
 AliMultiplicityCorrection.cxx:1335
 AliMultiplicityCorrection.cxx:1336
 AliMultiplicityCorrection.cxx:1337
 AliMultiplicityCorrection.cxx:1338
 AliMultiplicityCorrection.cxx:1339
 AliMultiplicityCorrection.cxx:1340
 AliMultiplicityCorrection.cxx:1341
 AliMultiplicityCorrection.cxx:1342
 AliMultiplicityCorrection.cxx:1343
 AliMultiplicityCorrection.cxx:1344
 AliMultiplicityCorrection.cxx:1345
 AliMultiplicityCorrection.cxx:1346
 AliMultiplicityCorrection.cxx:1347
 AliMultiplicityCorrection.cxx:1348
 AliMultiplicityCorrection.cxx:1349
 AliMultiplicityCorrection.cxx:1350
 AliMultiplicityCorrection.cxx:1351
 AliMultiplicityCorrection.cxx:1352
 AliMultiplicityCorrection.cxx:1353
 AliMultiplicityCorrection.cxx:1354
 AliMultiplicityCorrection.cxx:1355
 AliMultiplicityCorrection.cxx:1356
 AliMultiplicityCorrection.cxx:1357
 AliMultiplicityCorrection.cxx:1358
 AliMultiplicityCorrection.cxx:1359
 AliMultiplicityCorrection.cxx:1360
 AliMultiplicityCorrection.cxx:1361
 AliMultiplicityCorrection.cxx:1362
 AliMultiplicityCorrection.cxx:1363
 AliMultiplicityCorrection.cxx:1364
 AliMultiplicityCorrection.cxx:1365
 AliMultiplicityCorrection.cxx:1366
 AliMultiplicityCorrection.cxx:1367
 AliMultiplicityCorrection.cxx:1368
 AliMultiplicityCorrection.cxx:1369
 AliMultiplicityCorrection.cxx:1370
 AliMultiplicityCorrection.cxx:1371
 AliMultiplicityCorrection.cxx:1372
 AliMultiplicityCorrection.cxx:1373
 AliMultiplicityCorrection.cxx:1374
 AliMultiplicityCorrection.cxx:1375
 AliMultiplicityCorrection.cxx:1376
 AliMultiplicityCorrection.cxx:1377
 AliMultiplicityCorrection.cxx:1378
 AliMultiplicityCorrection.cxx:1379
 AliMultiplicityCorrection.cxx:1380
 AliMultiplicityCorrection.cxx:1381
 AliMultiplicityCorrection.cxx:1382
 AliMultiplicityCorrection.cxx:1383
 AliMultiplicityCorrection.cxx:1384
 AliMultiplicityCorrection.cxx:1385
 AliMultiplicityCorrection.cxx:1386
 AliMultiplicityCorrection.cxx:1387
 AliMultiplicityCorrection.cxx:1388
 AliMultiplicityCorrection.cxx:1389
 AliMultiplicityCorrection.cxx:1390
 AliMultiplicityCorrection.cxx:1391
 AliMultiplicityCorrection.cxx:1392
 AliMultiplicityCorrection.cxx:1393
 AliMultiplicityCorrection.cxx:1394
 AliMultiplicityCorrection.cxx:1395
 AliMultiplicityCorrection.cxx:1396
 AliMultiplicityCorrection.cxx:1397
 AliMultiplicityCorrection.cxx:1398
 AliMultiplicityCorrection.cxx:1399
 AliMultiplicityCorrection.cxx:1400
 AliMultiplicityCorrection.cxx:1401
 AliMultiplicityCorrection.cxx:1402
 AliMultiplicityCorrection.cxx:1403
 AliMultiplicityCorrection.cxx:1404
 AliMultiplicityCorrection.cxx:1405
 AliMultiplicityCorrection.cxx:1406
 AliMultiplicityCorrection.cxx:1407
 AliMultiplicityCorrection.cxx:1408
 AliMultiplicityCorrection.cxx:1409
 AliMultiplicityCorrection.cxx:1410
 AliMultiplicityCorrection.cxx:1411
 AliMultiplicityCorrection.cxx:1412
 AliMultiplicityCorrection.cxx:1413
 AliMultiplicityCorrection.cxx:1414
 AliMultiplicityCorrection.cxx:1415
 AliMultiplicityCorrection.cxx:1416
 AliMultiplicityCorrection.cxx:1417
 AliMultiplicityCorrection.cxx:1418
 AliMultiplicityCorrection.cxx:1419
 AliMultiplicityCorrection.cxx:1420
 AliMultiplicityCorrection.cxx:1421
 AliMultiplicityCorrection.cxx:1422
 AliMultiplicityCorrection.cxx:1423
 AliMultiplicityCorrection.cxx:1424
 AliMultiplicityCorrection.cxx:1425
 AliMultiplicityCorrection.cxx:1426
 AliMultiplicityCorrection.cxx:1427
 AliMultiplicityCorrection.cxx:1428
 AliMultiplicityCorrection.cxx:1429
 AliMultiplicityCorrection.cxx:1430
 AliMultiplicityCorrection.cxx:1431
 AliMultiplicityCorrection.cxx:1432
 AliMultiplicityCorrection.cxx:1433
 AliMultiplicityCorrection.cxx:1434
 AliMultiplicityCorrection.cxx:1435
 AliMultiplicityCorrection.cxx:1436
 AliMultiplicityCorrection.cxx:1437
 AliMultiplicityCorrection.cxx:1438
 AliMultiplicityCorrection.cxx:1439
 AliMultiplicityCorrection.cxx:1440
 AliMultiplicityCorrection.cxx:1441
 AliMultiplicityCorrection.cxx:1442
 AliMultiplicityCorrection.cxx:1443
 AliMultiplicityCorrection.cxx:1444
 AliMultiplicityCorrection.cxx:1445
 AliMultiplicityCorrection.cxx:1446
 AliMultiplicityCorrection.cxx:1447
 AliMultiplicityCorrection.cxx:1448
 AliMultiplicityCorrection.cxx:1449
 AliMultiplicityCorrection.cxx:1450
 AliMultiplicityCorrection.cxx:1451
 AliMultiplicityCorrection.cxx:1452
 AliMultiplicityCorrection.cxx:1453
 AliMultiplicityCorrection.cxx:1454
 AliMultiplicityCorrection.cxx:1455
 AliMultiplicityCorrection.cxx:1456
 AliMultiplicityCorrection.cxx:1457
 AliMultiplicityCorrection.cxx:1458
 AliMultiplicityCorrection.cxx:1459
 AliMultiplicityCorrection.cxx:1460
 AliMultiplicityCorrection.cxx:1461
 AliMultiplicityCorrection.cxx:1462
 AliMultiplicityCorrection.cxx:1463
 AliMultiplicityCorrection.cxx:1464
 AliMultiplicityCorrection.cxx:1465
 AliMultiplicityCorrection.cxx:1466
 AliMultiplicityCorrection.cxx:1467
 AliMultiplicityCorrection.cxx:1468
 AliMultiplicityCorrection.cxx:1469
 AliMultiplicityCorrection.cxx:1470
 AliMultiplicityCorrection.cxx:1471
 AliMultiplicityCorrection.cxx:1472
 AliMultiplicityCorrection.cxx:1473
 AliMultiplicityCorrection.cxx:1474
 AliMultiplicityCorrection.cxx:1475
 AliMultiplicityCorrection.cxx:1476
 AliMultiplicityCorrection.cxx:1477
 AliMultiplicityCorrection.cxx:1478
 AliMultiplicityCorrection.cxx:1479
 AliMultiplicityCorrection.cxx:1480
 AliMultiplicityCorrection.cxx:1481
 AliMultiplicityCorrection.cxx:1482
 AliMultiplicityCorrection.cxx:1483
 AliMultiplicityCorrection.cxx:1484
 AliMultiplicityCorrection.cxx:1485
 AliMultiplicityCorrection.cxx:1486
 AliMultiplicityCorrection.cxx:1487
 AliMultiplicityCorrection.cxx:1488
 AliMultiplicityCorrection.cxx:1489
 AliMultiplicityCorrection.cxx:1490
 AliMultiplicityCorrection.cxx:1491
 AliMultiplicityCorrection.cxx:1492
 AliMultiplicityCorrection.cxx:1493
 AliMultiplicityCorrection.cxx:1494
 AliMultiplicityCorrection.cxx:1495
 AliMultiplicityCorrection.cxx:1496
 AliMultiplicityCorrection.cxx:1497
 AliMultiplicityCorrection.cxx:1498
 AliMultiplicityCorrection.cxx:1499
 AliMultiplicityCorrection.cxx:1500
 AliMultiplicityCorrection.cxx:1501
 AliMultiplicityCorrection.cxx:1502
 AliMultiplicityCorrection.cxx:1503
 AliMultiplicityCorrection.cxx:1504
 AliMultiplicityCorrection.cxx:1505
 AliMultiplicityCorrection.cxx:1506
 AliMultiplicityCorrection.cxx:1507
 AliMultiplicityCorrection.cxx:1508
 AliMultiplicityCorrection.cxx:1509
 AliMultiplicityCorrection.cxx:1510
 AliMultiplicityCorrection.cxx:1511
 AliMultiplicityCorrection.cxx:1512
 AliMultiplicityCorrection.cxx:1513
 AliMultiplicityCorrection.cxx:1514
 AliMultiplicityCorrection.cxx:1515
 AliMultiplicityCorrection.cxx:1516
 AliMultiplicityCorrection.cxx:1517
 AliMultiplicityCorrection.cxx:1518
 AliMultiplicityCorrection.cxx:1519
 AliMultiplicityCorrection.cxx:1520
 AliMultiplicityCorrection.cxx:1521
 AliMultiplicityCorrection.cxx:1522
 AliMultiplicityCorrection.cxx:1523
 AliMultiplicityCorrection.cxx:1524
 AliMultiplicityCorrection.cxx:1525
 AliMultiplicityCorrection.cxx:1526
 AliMultiplicityCorrection.cxx:1527
 AliMultiplicityCorrection.cxx:1528
 AliMultiplicityCorrection.cxx:1529
 AliMultiplicityCorrection.cxx:1530
 AliMultiplicityCorrection.cxx:1531
 AliMultiplicityCorrection.cxx:1532
 AliMultiplicityCorrection.cxx:1533
 AliMultiplicityCorrection.cxx:1534
 AliMultiplicityCorrection.cxx:1535
 AliMultiplicityCorrection.cxx:1536
 AliMultiplicityCorrection.cxx:1537
 AliMultiplicityCorrection.cxx:1538
 AliMultiplicityCorrection.cxx:1539
 AliMultiplicityCorrection.cxx:1540
 AliMultiplicityCorrection.cxx:1541
 AliMultiplicityCorrection.cxx:1542
 AliMultiplicityCorrection.cxx:1543
 AliMultiplicityCorrection.cxx:1544
 AliMultiplicityCorrection.cxx:1545
 AliMultiplicityCorrection.cxx:1546
 AliMultiplicityCorrection.cxx:1547
 AliMultiplicityCorrection.cxx:1548
 AliMultiplicityCorrection.cxx:1549
 AliMultiplicityCorrection.cxx:1550
 AliMultiplicityCorrection.cxx:1551
 AliMultiplicityCorrection.cxx:1552
 AliMultiplicityCorrection.cxx:1553
 AliMultiplicityCorrection.cxx:1554
 AliMultiplicityCorrection.cxx:1555
 AliMultiplicityCorrection.cxx:1556
 AliMultiplicityCorrection.cxx:1557
 AliMultiplicityCorrection.cxx:1558
 AliMultiplicityCorrection.cxx:1559
 AliMultiplicityCorrection.cxx:1560
 AliMultiplicityCorrection.cxx:1561
 AliMultiplicityCorrection.cxx:1562
 AliMultiplicityCorrection.cxx:1563
 AliMultiplicityCorrection.cxx:1564
 AliMultiplicityCorrection.cxx:1565
 AliMultiplicityCorrection.cxx:1566
 AliMultiplicityCorrection.cxx:1567
 AliMultiplicityCorrection.cxx:1568
 AliMultiplicityCorrection.cxx:1569
 AliMultiplicityCorrection.cxx:1570
 AliMultiplicityCorrection.cxx:1571
 AliMultiplicityCorrection.cxx:1572
 AliMultiplicityCorrection.cxx:1573
 AliMultiplicityCorrection.cxx:1574
 AliMultiplicityCorrection.cxx:1575
 AliMultiplicityCorrection.cxx:1576
 AliMultiplicityCorrection.cxx:1577
 AliMultiplicityCorrection.cxx:1578
 AliMultiplicityCorrection.cxx:1579
 AliMultiplicityCorrection.cxx:1580
 AliMultiplicityCorrection.cxx:1581
 AliMultiplicityCorrection.cxx:1582
 AliMultiplicityCorrection.cxx:1583
 AliMultiplicityCorrection.cxx:1584
 AliMultiplicityCorrection.cxx:1585
 AliMultiplicityCorrection.cxx:1586
 AliMultiplicityCorrection.cxx:1587
 AliMultiplicityCorrection.cxx:1588
 AliMultiplicityCorrection.cxx:1589
 AliMultiplicityCorrection.cxx:1590
 AliMultiplicityCorrection.cxx:1591
 AliMultiplicityCorrection.cxx:1592
 AliMultiplicityCorrection.cxx:1593
 AliMultiplicityCorrection.cxx:1594
 AliMultiplicityCorrection.cxx:1595
 AliMultiplicityCorrection.cxx:1596
 AliMultiplicityCorrection.cxx:1597
 AliMultiplicityCorrection.cxx:1598
 AliMultiplicityCorrection.cxx:1599
 AliMultiplicityCorrection.cxx:1600
 AliMultiplicityCorrection.cxx:1601
 AliMultiplicityCorrection.cxx:1602
 AliMultiplicityCorrection.cxx:1603
 AliMultiplicityCorrection.cxx:1604
 AliMultiplicityCorrection.cxx:1605
 AliMultiplicityCorrection.cxx:1606
 AliMultiplicityCorrection.cxx:1607
 AliMultiplicityCorrection.cxx:1608
 AliMultiplicityCorrection.cxx:1609
 AliMultiplicityCorrection.cxx:1610
 AliMultiplicityCorrection.cxx:1611
 AliMultiplicityCorrection.cxx:1612
 AliMultiplicityCorrection.cxx:1613
 AliMultiplicityCorrection.cxx:1614
 AliMultiplicityCorrection.cxx:1615
 AliMultiplicityCorrection.cxx:1616
 AliMultiplicityCorrection.cxx:1617
 AliMultiplicityCorrection.cxx:1618
 AliMultiplicityCorrection.cxx:1619
 AliMultiplicityCorrection.cxx:1620
 AliMultiplicityCorrection.cxx:1621
 AliMultiplicityCorrection.cxx:1622
 AliMultiplicityCorrection.cxx:1623
 AliMultiplicityCorrection.cxx:1624
 AliMultiplicityCorrection.cxx:1625
 AliMultiplicityCorrection.cxx:1626
 AliMultiplicityCorrection.cxx:1627
 AliMultiplicityCorrection.cxx:1628
 AliMultiplicityCorrection.cxx:1629
 AliMultiplicityCorrection.cxx:1630
 AliMultiplicityCorrection.cxx:1631
 AliMultiplicityCorrection.cxx:1632
 AliMultiplicityCorrection.cxx:1633
 AliMultiplicityCorrection.cxx:1634
 AliMultiplicityCorrection.cxx:1635
 AliMultiplicityCorrection.cxx:1636
 AliMultiplicityCorrection.cxx:1637
 AliMultiplicityCorrection.cxx:1638
 AliMultiplicityCorrection.cxx:1639
 AliMultiplicityCorrection.cxx:1640
 AliMultiplicityCorrection.cxx:1641
 AliMultiplicityCorrection.cxx:1642
 AliMultiplicityCorrection.cxx:1643
 AliMultiplicityCorrection.cxx:1644
 AliMultiplicityCorrection.cxx:1645
 AliMultiplicityCorrection.cxx:1646
 AliMultiplicityCorrection.cxx:1647
 AliMultiplicityCorrection.cxx:1648
 AliMultiplicityCorrection.cxx:1649
 AliMultiplicityCorrection.cxx:1650
 AliMultiplicityCorrection.cxx:1651
 AliMultiplicityCorrection.cxx:1652
 AliMultiplicityCorrection.cxx:1653
 AliMultiplicityCorrection.cxx:1654
 AliMultiplicityCorrection.cxx:1655
 AliMultiplicityCorrection.cxx:1656
 AliMultiplicityCorrection.cxx:1657
 AliMultiplicityCorrection.cxx:1658
 AliMultiplicityCorrection.cxx:1659
 AliMultiplicityCorrection.cxx:1660
 AliMultiplicityCorrection.cxx:1661
 AliMultiplicityCorrection.cxx:1662
 AliMultiplicityCorrection.cxx:1663
 AliMultiplicityCorrection.cxx:1664
 AliMultiplicityCorrection.cxx:1665
 AliMultiplicityCorrection.cxx:1666
 AliMultiplicityCorrection.cxx:1667
 AliMultiplicityCorrection.cxx:1668
 AliMultiplicityCorrection.cxx:1669
 AliMultiplicityCorrection.cxx:1670
 AliMultiplicityCorrection.cxx:1671
 AliMultiplicityCorrection.cxx:1672
 AliMultiplicityCorrection.cxx:1673
 AliMultiplicityCorrection.cxx:1674
 AliMultiplicityCorrection.cxx:1675
 AliMultiplicityCorrection.cxx:1676
 AliMultiplicityCorrection.cxx:1677
 AliMultiplicityCorrection.cxx:1678
 AliMultiplicityCorrection.cxx:1679
 AliMultiplicityCorrection.cxx:1680
 AliMultiplicityCorrection.cxx:1681
 AliMultiplicityCorrection.cxx:1682
 AliMultiplicityCorrection.cxx:1683
 AliMultiplicityCorrection.cxx:1684
 AliMultiplicityCorrection.cxx:1685
 AliMultiplicityCorrection.cxx:1686
 AliMultiplicityCorrection.cxx:1687
 AliMultiplicityCorrection.cxx:1688
 AliMultiplicityCorrection.cxx:1689
 AliMultiplicityCorrection.cxx:1690
 AliMultiplicityCorrection.cxx:1691
 AliMultiplicityCorrection.cxx:1692
 AliMultiplicityCorrection.cxx:1693
 AliMultiplicityCorrection.cxx:1694
 AliMultiplicityCorrection.cxx:1695
 AliMultiplicityCorrection.cxx:1696
 AliMultiplicityCorrection.cxx:1697
 AliMultiplicityCorrection.cxx:1698
 AliMultiplicityCorrection.cxx:1699
 AliMultiplicityCorrection.cxx:1700
 AliMultiplicityCorrection.cxx:1701
 AliMultiplicityCorrection.cxx:1702
 AliMultiplicityCorrection.cxx:1703
 AliMultiplicityCorrection.cxx:1704
 AliMultiplicityCorrection.cxx:1705
 AliMultiplicityCorrection.cxx:1706
 AliMultiplicityCorrection.cxx:1707
 AliMultiplicityCorrection.cxx:1708
 AliMultiplicityCorrection.cxx:1709
 AliMultiplicityCorrection.cxx:1710
 AliMultiplicityCorrection.cxx:1711
 AliMultiplicityCorrection.cxx:1712
 AliMultiplicityCorrection.cxx:1713
 AliMultiplicityCorrection.cxx:1714
 AliMultiplicityCorrection.cxx:1715
 AliMultiplicityCorrection.cxx:1716
 AliMultiplicityCorrection.cxx:1717
 AliMultiplicityCorrection.cxx:1718
 AliMultiplicityCorrection.cxx:1719
 AliMultiplicityCorrection.cxx:1720
 AliMultiplicityCorrection.cxx:1721
 AliMultiplicityCorrection.cxx:1722
 AliMultiplicityCorrection.cxx:1723
 AliMultiplicityCorrection.cxx:1724
 AliMultiplicityCorrection.cxx:1725
 AliMultiplicityCorrection.cxx:1726
 AliMultiplicityCorrection.cxx:1727
 AliMultiplicityCorrection.cxx:1728
 AliMultiplicityCorrection.cxx:1729
 AliMultiplicityCorrection.cxx:1730
 AliMultiplicityCorrection.cxx:1731
 AliMultiplicityCorrection.cxx:1732
 AliMultiplicityCorrection.cxx:1733
 AliMultiplicityCorrection.cxx:1734
 AliMultiplicityCorrection.cxx:1735
 AliMultiplicityCorrection.cxx:1736
 AliMultiplicityCorrection.cxx:1737
 AliMultiplicityCorrection.cxx:1738
 AliMultiplicityCorrection.cxx:1739
 AliMultiplicityCorrection.cxx:1740
 AliMultiplicityCorrection.cxx:1741
 AliMultiplicityCorrection.cxx:1742
 AliMultiplicityCorrection.cxx:1743
 AliMultiplicityCorrection.cxx:1744
 AliMultiplicityCorrection.cxx:1745
 AliMultiplicityCorrection.cxx:1746
 AliMultiplicityCorrection.cxx:1747
 AliMultiplicityCorrection.cxx:1748
 AliMultiplicityCorrection.cxx:1749
 AliMultiplicityCorrection.cxx:1750
 AliMultiplicityCorrection.cxx:1751
 AliMultiplicityCorrection.cxx:1752
 AliMultiplicityCorrection.cxx:1753
 AliMultiplicityCorrection.cxx:1754
 AliMultiplicityCorrection.cxx:1755
 AliMultiplicityCorrection.cxx:1756
 AliMultiplicityCorrection.cxx:1757
 AliMultiplicityCorrection.cxx:1758
 AliMultiplicityCorrection.cxx:1759
 AliMultiplicityCorrection.cxx:1760
 AliMultiplicityCorrection.cxx:1761
 AliMultiplicityCorrection.cxx:1762
 AliMultiplicityCorrection.cxx:1763
 AliMultiplicityCorrection.cxx:1764
 AliMultiplicityCorrection.cxx:1765
 AliMultiplicityCorrection.cxx:1766
 AliMultiplicityCorrection.cxx:1767
 AliMultiplicityCorrection.cxx:1768
 AliMultiplicityCorrection.cxx:1769
 AliMultiplicityCorrection.cxx:1770
 AliMultiplicityCorrection.cxx:1771
 AliMultiplicityCorrection.cxx:1772
 AliMultiplicityCorrection.cxx:1773
 AliMultiplicityCorrection.cxx:1774
 AliMultiplicityCorrection.cxx:1775
 AliMultiplicityCorrection.cxx:1776
 AliMultiplicityCorrection.cxx:1777
 AliMultiplicityCorrection.cxx:1778
 AliMultiplicityCorrection.cxx:1779
 AliMultiplicityCorrection.cxx:1780
 AliMultiplicityCorrection.cxx:1781
 AliMultiplicityCorrection.cxx:1782
 AliMultiplicityCorrection.cxx:1783
 AliMultiplicityCorrection.cxx:1784
 AliMultiplicityCorrection.cxx:1785
 AliMultiplicityCorrection.cxx:1786
 AliMultiplicityCorrection.cxx:1787
 AliMultiplicityCorrection.cxx:1788
 AliMultiplicityCorrection.cxx:1789
 AliMultiplicityCorrection.cxx:1790
 AliMultiplicityCorrection.cxx:1791
 AliMultiplicityCorrection.cxx:1792
 AliMultiplicityCorrection.cxx:1793
 AliMultiplicityCorrection.cxx:1794
 AliMultiplicityCorrection.cxx:1795
 AliMultiplicityCorrection.cxx:1796
 AliMultiplicityCorrection.cxx:1797
 AliMultiplicityCorrection.cxx:1798
 AliMultiplicityCorrection.cxx:1799
 AliMultiplicityCorrection.cxx:1800
 AliMultiplicityCorrection.cxx:1801
 AliMultiplicityCorrection.cxx:1802
 AliMultiplicityCorrection.cxx:1803
 AliMultiplicityCorrection.cxx:1804
 AliMultiplicityCorrection.cxx:1805
 AliMultiplicityCorrection.cxx:1806
 AliMultiplicityCorrection.cxx:1807
 AliMultiplicityCorrection.cxx:1808
 AliMultiplicityCorrection.cxx:1809
 AliMultiplicityCorrection.cxx:1810
 AliMultiplicityCorrection.cxx:1811
 AliMultiplicityCorrection.cxx:1812
 AliMultiplicityCorrection.cxx:1813
 AliMultiplicityCorrection.cxx:1814
 AliMultiplicityCorrection.cxx:1815
 AliMultiplicityCorrection.cxx:1816
 AliMultiplicityCorrection.cxx:1817
 AliMultiplicityCorrection.cxx:1818
 AliMultiplicityCorrection.cxx:1819
 AliMultiplicityCorrection.cxx:1820
 AliMultiplicityCorrection.cxx:1821
 AliMultiplicityCorrection.cxx:1822
 AliMultiplicityCorrection.cxx:1823
 AliMultiplicityCorrection.cxx:1824
 AliMultiplicityCorrection.cxx:1825
 AliMultiplicityCorrection.cxx:1826
 AliMultiplicityCorrection.cxx:1827
 AliMultiplicityCorrection.cxx:1828
 AliMultiplicityCorrection.cxx:1829
 AliMultiplicityCorrection.cxx:1830
 AliMultiplicityCorrection.cxx:1831
 AliMultiplicityCorrection.cxx:1832
 AliMultiplicityCorrection.cxx:1833
 AliMultiplicityCorrection.cxx:1834
 AliMultiplicityCorrection.cxx:1835
 AliMultiplicityCorrection.cxx:1836
 AliMultiplicityCorrection.cxx:1837
 AliMultiplicityCorrection.cxx:1838
 AliMultiplicityCorrection.cxx:1839
 AliMultiplicityCorrection.cxx:1840
 AliMultiplicityCorrection.cxx:1841
 AliMultiplicityCorrection.cxx:1842
 AliMultiplicityCorrection.cxx:1843
 AliMultiplicityCorrection.cxx:1844
 AliMultiplicityCorrection.cxx:1845
 AliMultiplicityCorrection.cxx:1846
 AliMultiplicityCorrection.cxx:1847
 AliMultiplicityCorrection.cxx:1848
 AliMultiplicityCorrection.cxx:1849
 AliMultiplicityCorrection.cxx:1850
 AliMultiplicityCorrection.cxx:1851
 AliMultiplicityCorrection.cxx:1852
 AliMultiplicityCorrection.cxx:1853
 AliMultiplicityCorrection.cxx:1854
 AliMultiplicityCorrection.cxx:1855
 AliMultiplicityCorrection.cxx:1856
 AliMultiplicityCorrection.cxx:1857
 AliMultiplicityCorrection.cxx:1858
 AliMultiplicityCorrection.cxx:1859
 AliMultiplicityCorrection.cxx:1860
 AliMultiplicityCorrection.cxx:1861
 AliMultiplicityCorrection.cxx:1862
 AliMultiplicityCorrection.cxx:1863
 AliMultiplicityCorrection.cxx:1864
 AliMultiplicityCorrection.cxx:1865
 AliMultiplicityCorrection.cxx:1866
 AliMultiplicityCorrection.cxx:1867
 AliMultiplicityCorrection.cxx:1868
 AliMultiplicityCorrection.cxx:1869
 AliMultiplicityCorrection.cxx:1870
 AliMultiplicityCorrection.cxx:1871
 AliMultiplicityCorrection.cxx:1872
 AliMultiplicityCorrection.cxx:1873
 AliMultiplicityCorrection.cxx:1874
 AliMultiplicityCorrection.cxx:1875
 AliMultiplicityCorrection.cxx:1876
 AliMultiplicityCorrection.cxx:1877
 AliMultiplicityCorrection.cxx:1878
 AliMultiplicityCorrection.cxx:1879
 AliMultiplicityCorrection.cxx:1880
 AliMultiplicityCorrection.cxx:1881
 AliMultiplicityCorrection.cxx:1882
 AliMultiplicityCorrection.cxx:1883
 AliMultiplicityCorrection.cxx:1884
 AliMultiplicityCorrection.cxx:1885
 AliMultiplicityCorrection.cxx:1886
 AliMultiplicityCorrection.cxx:1887
 AliMultiplicityCorrection.cxx:1888
 AliMultiplicityCorrection.cxx:1889
 AliMultiplicityCorrection.cxx:1890
 AliMultiplicityCorrection.cxx:1891
 AliMultiplicityCorrection.cxx:1892
 AliMultiplicityCorrection.cxx:1893
 AliMultiplicityCorrection.cxx:1894
 AliMultiplicityCorrection.cxx:1895
 AliMultiplicityCorrection.cxx:1896
 AliMultiplicityCorrection.cxx:1897
 AliMultiplicityCorrection.cxx:1898
 AliMultiplicityCorrection.cxx:1899
 AliMultiplicityCorrection.cxx:1900
 AliMultiplicityCorrection.cxx:1901
 AliMultiplicityCorrection.cxx:1902
 AliMultiplicityCorrection.cxx:1903
 AliMultiplicityCorrection.cxx:1904
 AliMultiplicityCorrection.cxx:1905
 AliMultiplicityCorrection.cxx:1906
 AliMultiplicityCorrection.cxx:1907
 AliMultiplicityCorrection.cxx:1908
 AliMultiplicityCorrection.cxx:1909
 AliMultiplicityCorrection.cxx:1910
 AliMultiplicityCorrection.cxx:1911
 AliMultiplicityCorrection.cxx:1912
 AliMultiplicityCorrection.cxx:1913
 AliMultiplicityCorrection.cxx:1914
 AliMultiplicityCorrection.cxx:1915
 AliMultiplicityCorrection.cxx:1916
 AliMultiplicityCorrection.cxx:1917
 AliMultiplicityCorrection.cxx:1918
 AliMultiplicityCorrection.cxx:1919
 AliMultiplicityCorrection.cxx:1920
 AliMultiplicityCorrection.cxx:1921
 AliMultiplicityCorrection.cxx:1922
 AliMultiplicityCorrection.cxx:1923
 AliMultiplicityCorrection.cxx:1924
 AliMultiplicityCorrection.cxx:1925
 AliMultiplicityCorrection.cxx:1926
 AliMultiplicityCorrection.cxx:1927
 AliMultiplicityCorrection.cxx:1928
 AliMultiplicityCorrection.cxx:1929
 AliMultiplicityCorrection.cxx:1930
 AliMultiplicityCorrection.cxx:1931
 AliMultiplicityCorrection.cxx:1932
 AliMultiplicityCorrection.cxx:1933
 AliMultiplicityCorrection.cxx:1934
 AliMultiplicityCorrection.cxx:1935
 AliMultiplicityCorrection.cxx:1936
 AliMultiplicityCorrection.cxx:1937
 AliMultiplicityCorrection.cxx:1938
 AliMultiplicityCorrection.cxx:1939
 AliMultiplicityCorrection.cxx:1940
 AliMultiplicityCorrection.cxx:1941
 AliMultiplicityCorrection.cxx:1942
 AliMultiplicityCorrection.cxx:1943
 AliMultiplicityCorrection.cxx:1944
 AliMultiplicityCorrection.cxx:1945
 AliMultiplicityCorrection.cxx:1946
 AliMultiplicityCorrection.cxx:1947
 AliMultiplicityCorrection.cxx:1948
 AliMultiplicityCorrection.cxx:1949
 AliMultiplicityCorrection.cxx:1950
 AliMultiplicityCorrection.cxx:1951
 AliMultiplicityCorrection.cxx:1952
 AliMultiplicityCorrection.cxx:1953
 AliMultiplicityCorrection.cxx:1954
 AliMultiplicityCorrection.cxx:1955
 AliMultiplicityCorrection.cxx:1956
 AliMultiplicityCorrection.cxx:1957
 AliMultiplicityCorrection.cxx:1958
 AliMultiplicityCorrection.cxx:1959
 AliMultiplicityCorrection.cxx:1960
 AliMultiplicityCorrection.cxx:1961
 AliMultiplicityCorrection.cxx:1962
 AliMultiplicityCorrection.cxx:1963
 AliMultiplicityCorrection.cxx:1964
 AliMultiplicityCorrection.cxx:1965
 AliMultiplicityCorrection.cxx:1966
 AliMultiplicityCorrection.cxx:1967
 AliMultiplicityCorrection.cxx:1968
 AliMultiplicityCorrection.cxx:1969
 AliMultiplicityCorrection.cxx:1970
 AliMultiplicityCorrection.cxx:1971
 AliMultiplicityCorrection.cxx:1972
 AliMultiplicityCorrection.cxx:1973
 AliMultiplicityCorrection.cxx:1974
 AliMultiplicityCorrection.cxx:1975
 AliMultiplicityCorrection.cxx:1976
 AliMultiplicityCorrection.cxx:1977
 AliMultiplicityCorrection.cxx:1978
 AliMultiplicityCorrection.cxx:1979
 AliMultiplicityCorrection.cxx:1980
 AliMultiplicityCorrection.cxx:1981
 AliMultiplicityCorrection.cxx:1982
 AliMultiplicityCorrection.cxx:1983
 AliMultiplicityCorrection.cxx:1984
 AliMultiplicityCorrection.cxx:1985
 AliMultiplicityCorrection.cxx:1986
 AliMultiplicityCorrection.cxx:1987
 AliMultiplicityCorrection.cxx:1988
 AliMultiplicityCorrection.cxx:1989
 AliMultiplicityCorrection.cxx:1990
 AliMultiplicityCorrection.cxx:1991
 AliMultiplicityCorrection.cxx:1992
 AliMultiplicityCorrection.cxx:1993
 AliMultiplicityCorrection.cxx:1994
 AliMultiplicityCorrection.cxx:1995
 AliMultiplicityCorrection.cxx:1996
 AliMultiplicityCorrection.cxx:1997
 AliMultiplicityCorrection.cxx:1998
 AliMultiplicityCorrection.cxx:1999
 AliMultiplicityCorrection.cxx:2000
 AliMultiplicityCorrection.cxx:2001
 AliMultiplicityCorrection.cxx:2002
 AliMultiplicityCorrection.cxx:2003
 AliMultiplicityCorrection.cxx:2004
 AliMultiplicityCorrection.cxx:2005
 AliMultiplicityCorrection.cxx:2006
 AliMultiplicityCorrection.cxx:2007
 AliMultiplicityCorrection.cxx:2008
 AliMultiplicityCorrection.cxx:2009
 AliMultiplicityCorrection.cxx:2010
 AliMultiplicityCorrection.cxx:2011
 AliMultiplicityCorrection.cxx:2012
 AliMultiplicityCorrection.cxx:2013
 AliMultiplicityCorrection.cxx:2014
 AliMultiplicityCorrection.cxx:2015
 AliMultiplicityCorrection.cxx:2016
 AliMultiplicityCorrection.cxx:2017
 AliMultiplicityCorrection.cxx:2018
 AliMultiplicityCorrection.cxx:2019
 AliMultiplicityCorrection.cxx:2020
 AliMultiplicityCorrection.cxx:2021
 AliMultiplicityCorrection.cxx:2022
 AliMultiplicityCorrection.cxx:2023
 AliMultiplicityCorrection.cxx:2024
 AliMultiplicityCorrection.cxx:2025
 AliMultiplicityCorrection.cxx:2026
 AliMultiplicityCorrection.cxx:2027
 AliMultiplicityCorrection.cxx:2028
 AliMultiplicityCorrection.cxx:2029
 AliMultiplicityCorrection.cxx:2030
 AliMultiplicityCorrection.cxx:2031
 AliMultiplicityCorrection.cxx:2032
 AliMultiplicityCorrection.cxx:2033
 AliMultiplicityCorrection.cxx:2034
 AliMultiplicityCorrection.cxx:2035
 AliMultiplicityCorrection.cxx:2036
 AliMultiplicityCorrection.cxx:2037
 AliMultiplicityCorrection.cxx:2038
 AliMultiplicityCorrection.cxx:2039
 AliMultiplicityCorrection.cxx:2040
 AliMultiplicityCorrection.cxx:2041
 AliMultiplicityCorrection.cxx:2042
 AliMultiplicityCorrection.cxx:2043
 AliMultiplicityCorrection.cxx:2044
 AliMultiplicityCorrection.cxx:2045
 AliMultiplicityCorrection.cxx:2046
 AliMultiplicityCorrection.cxx:2047
 AliMultiplicityCorrection.cxx:2048
 AliMultiplicityCorrection.cxx:2049
 AliMultiplicityCorrection.cxx:2050
 AliMultiplicityCorrection.cxx:2051
 AliMultiplicityCorrection.cxx:2052
 AliMultiplicityCorrection.cxx:2053
 AliMultiplicityCorrection.cxx:2054
 AliMultiplicityCorrection.cxx:2055
 AliMultiplicityCorrection.cxx:2056
 AliMultiplicityCorrection.cxx:2057
 AliMultiplicityCorrection.cxx:2058
 AliMultiplicityCorrection.cxx:2059
 AliMultiplicityCorrection.cxx:2060
 AliMultiplicityCorrection.cxx:2061
 AliMultiplicityCorrection.cxx:2062
 AliMultiplicityCorrection.cxx:2063
 AliMultiplicityCorrection.cxx:2064
 AliMultiplicityCorrection.cxx:2065
 AliMultiplicityCorrection.cxx:2066
 AliMultiplicityCorrection.cxx:2067
 AliMultiplicityCorrection.cxx:2068
 AliMultiplicityCorrection.cxx:2069
 AliMultiplicityCorrection.cxx:2070
 AliMultiplicityCorrection.cxx:2071
 AliMultiplicityCorrection.cxx:2072
 AliMultiplicityCorrection.cxx:2073
 AliMultiplicityCorrection.cxx:2074
 AliMultiplicityCorrection.cxx:2075
 AliMultiplicityCorrection.cxx:2076
 AliMultiplicityCorrection.cxx:2077
 AliMultiplicityCorrection.cxx:2078
 AliMultiplicityCorrection.cxx:2079
 AliMultiplicityCorrection.cxx:2080
 AliMultiplicityCorrection.cxx:2081
 AliMultiplicityCorrection.cxx:2082
 AliMultiplicityCorrection.cxx:2083
 AliMultiplicityCorrection.cxx:2084
 AliMultiplicityCorrection.cxx:2085
 AliMultiplicityCorrection.cxx:2086
 AliMultiplicityCorrection.cxx:2087
 AliMultiplicityCorrection.cxx:2088
 AliMultiplicityCorrection.cxx:2089
 AliMultiplicityCorrection.cxx:2090
 AliMultiplicityCorrection.cxx:2091
 AliMultiplicityCorrection.cxx:2092
 AliMultiplicityCorrection.cxx:2093
 AliMultiplicityCorrection.cxx:2094
 AliMultiplicityCorrection.cxx:2095
 AliMultiplicityCorrection.cxx:2096
 AliMultiplicityCorrection.cxx:2097
 AliMultiplicityCorrection.cxx:2098
 AliMultiplicityCorrection.cxx:2099
 AliMultiplicityCorrection.cxx:2100
 AliMultiplicityCorrection.cxx:2101
 AliMultiplicityCorrection.cxx:2102
 AliMultiplicityCorrection.cxx:2103
 AliMultiplicityCorrection.cxx:2104
 AliMultiplicityCorrection.cxx:2105
 AliMultiplicityCorrection.cxx:2106
 AliMultiplicityCorrection.cxx:2107
 AliMultiplicityCorrection.cxx:2108
 AliMultiplicityCorrection.cxx:2109
 AliMultiplicityCorrection.cxx:2110
 AliMultiplicityCorrection.cxx:2111
 AliMultiplicityCorrection.cxx:2112
 AliMultiplicityCorrection.cxx:2113
 AliMultiplicityCorrection.cxx:2114
 AliMultiplicityCorrection.cxx:2115
 AliMultiplicityCorrection.cxx:2116
 AliMultiplicityCorrection.cxx:2117
 AliMultiplicityCorrection.cxx:2118
 AliMultiplicityCorrection.cxx:2119
 AliMultiplicityCorrection.cxx:2120
 AliMultiplicityCorrection.cxx:2121
 AliMultiplicityCorrection.cxx:2122
 AliMultiplicityCorrection.cxx:2123
 AliMultiplicityCorrection.cxx:2124
 AliMultiplicityCorrection.cxx:2125
 AliMultiplicityCorrection.cxx:2126
 AliMultiplicityCorrection.cxx:2127
 AliMultiplicityCorrection.cxx:2128
 AliMultiplicityCorrection.cxx:2129
 AliMultiplicityCorrection.cxx:2130
 AliMultiplicityCorrection.cxx:2131
 AliMultiplicityCorrection.cxx:2132
 AliMultiplicityCorrection.cxx:2133
 AliMultiplicityCorrection.cxx:2134
 AliMultiplicityCorrection.cxx:2135
 AliMultiplicityCorrection.cxx:2136
 AliMultiplicityCorrection.cxx:2137
 AliMultiplicityCorrection.cxx:2138
 AliMultiplicityCorrection.cxx:2139
 AliMultiplicityCorrection.cxx:2140
 AliMultiplicityCorrection.cxx:2141
 AliMultiplicityCorrection.cxx:2142
 AliMultiplicityCorrection.cxx:2143
 AliMultiplicityCorrection.cxx:2144
 AliMultiplicityCorrection.cxx:2145
 AliMultiplicityCorrection.cxx:2146
 AliMultiplicityCorrection.cxx:2147
 AliMultiplicityCorrection.cxx:2148
 AliMultiplicityCorrection.cxx:2149
 AliMultiplicityCorrection.cxx:2150
 AliMultiplicityCorrection.cxx:2151
 AliMultiplicityCorrection.cxx:2152
 AliMultiplicityCorrection.cxx:2153
 AliMultiplicityCorrection.cxx:2154
 AliMultiplicityCorrection.cxx:2155
 AliMultiplicityCorrection.cxx:2156
 AliMultiplicityCorrection.cxx:2157
 AliMultiplicityCorrection.cxx:2158
 AliMultiplicityCorrection.cxx:2159
 AliMultiplicityCorrection.cxx:2160
 AliMultiplicityCorrection.cxx:2161
 AliMultiplicityCorrection.cxx:2162
 AliMultiplicityCorrection.cxx:2163
 AliMultiplicityCorrection.cxx:2164
 AliMultiplicityCorrection.cxx:2165
 AliMultiplicityCorrection.cxx:2166
 AliMultiplicityCorrection.cxx:2167
 AliMultiplicityCorrection.cxx:2168
 AliMultiplicityCorrection.cxx:2169
 AliMultiplicityCorrection.cxx:2170
 AliMultiplicityCorrection.cxx:2171
 AliMultiplicityCorrection.cxx:2172
 AliMultiplicityCorrection.cxx:2173
 AliMultiplicityCorrection.cxx:2174
 AliMultiplicityCorrection.cxx:2175
 AliMultiplicityCorrection.cxx:2176
 AliMultiplicityCorrection.cxx:2177
 AliMultiplicityCorrection.cxx:2178
 AliMultiplicityCorrection.cxx:2179
 AliMultiplicityCorrection.cxx:2180
 AliMultiplicityCorrection.cxx:2181
 AliMultiplicityCorrection.cxx:2182
 AliMultiplicityCorrection.cxx:2183
 AliMultiplicityCorrection.cxx:2184
 AliMultiplicityCorrection.cxx:2185
 AliMultiplicityCorrection.cxx:2186
 AliMultiplicityCorrection.cxx:2187
 AliMultiplicityCorrection.cxx:2188
 AliMultiplicityCorrection.cxx:2189
 AliMultiplicityCorrection.cxx:2190
 AliMultiplicityCorrection.cxx:2191
 AliMultiplicityCorrection.cxx:2192
 AliMultiplicityCorrection.cxx:2193
 AliMultiplicityCorrection.cxx:2194
 AliMultiplicityCorrection.cxx:2195
 AliMultiplicityCorrection.cxx:2196
 AliMultiplicityCorrection.cxx:2197
 AliMultiplicityCorrection.cxx:2198
 AliMultiplicityCorrection.cxx:2199
 AliMultiplicityCorrection.cxx:2200
 AliMultiplicityCorrection.cxx:2201
 AliMultiplicityCorrection.cxx:2202
 AliMultiplicityCorrection.cxx:2203
 AliMultiplicityCorrection.cxx:2204
 AliMultiplicityCorrection.cxx:2205
 AliMultiplicityCorrection.cxx:2206
 AliMultiplicityCorrection.cxx:2207
 AliMultiplicityCorrection.cxx:2208
 AliMultiplicityCorrection.cxx:2209
 AliMultiplicityCorrection.cxx:2210
 AliMultiplicityCorrection.cxx:2211
 AliMultiplicityCorrection.cxx:2212
 AliMultiplicityCorrection.cxx:2213
 AliMultiplicityCorrection.cxx:2214
 AliMultiplicityCorrection.cxx:2215
 AliMultiplicityCorrection.cxx:2216
 AliMultiplicityCorrection.cxx:2217
 AliMultiplicityCorrection.cxx:2218
 AliMultiplicityCorrection.cxx:2219
 AliMultiplicityCorrection.cxx:2220
 AliMultiplicityCorrection.cxx:2221
 AliMultiplicityCorrection.cxx:2222
 AliMultiplicityCorrection.cxx:2223
 AliMultiplicityCorrection.cxx:2224
 AliMultiplicityCorrection.cxx:2225
 AliMultiplicityCorrection.cxx:2226
 AliMultiplicityCorrection.cxx:2227
 AliMultiplicityCorrection.cxx:2228
 AliMultiplicityCorrection.cxx:2229