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: AliUEHist.cxx 20164 2007-08-14 15:31:50Z morsch $ */

//
//
// encapsulate histogram and corrections for one underlying event histogram
//
//
// Author: Jan Fiete Grosse-Oetringhaus, Sara Vallero

#include "AliUEHist.h"
#include "AliCFContainer.h"
#include "THnSparse.h"
#include "TMath.h"
#include "TList.h"
#include "TCollection.h"
#include "TH1D.h"
#include "TH2D.h"
#include "TH3D.h"
#include "AliLog.h"
#include "TCanvas.h"
#include "TF1.h"
#include "AliTHn.h"
#include "THn.h"

ClassImp(AliUEHist)

const Int_t AliUEHist::fgkCFSteps = 11;

AliUEHist::AliUEHist(const char* reqHist, const char* binning) : 
  TObject(),
  fkRegions(4),
  fEventHist(0),
  fTrackHistEfficiency(0),
  fFakePt(0),
  fEtaMin(0),
  fEtaMax(0),
  fPtMin(0),
  fPtMax(0),
  fPartSpecies(-1),
  fCentralityMin(0),
  fCentralityMax(0),
  fZVtxMin(0),
  fZVtxMax(0),
  fPt2Min(0),
  fContaminationEnhancement(0),
  fCombineMinMax(0),
  fTrackEtaCut(0),
  fWeightPerEvent(0),
  fSkipScaleMixedEvent(kFALSE),
  fCache(0),
  fGetMultCacheOn(kFALSE),
  fGetMultCache(0),
  fHistogramType(reqHist)
{
  // Constructor
    
  for (UInt_t i=0; i<fkRegions; i++)
    fTrackHist[i] = 0;
    
  if (strlen(reqHist) == 0)
    return;
  
  Printf("Creating AliUEHist with %s (binning: %s)", reqHist, binning);
    
  AliLog::SetClassDebugLevel("AliCFContainer", -1);
  AliLog::SetClassDebugLevel("AliCFGridSparse", -3);
    
  const char* title = "";
    
  // track level
  Int_t nTrackVars = 4; // eta vs pT vs pT,lead (vs delta phi) vs multiplicity
  Int_t iTrackBin[7];
  Double_t* trackBins[7];
  const char* trackAxisTitle[7];
  
  // eta
  Int_t nEtaBins = -1;
  Double_t* etaBins = GetBinning(binning, "eta", nEtaBins);
  const char* etaTitle = "#eta";
  
  iTrackBin[0] = nEtaBins;
  trackBins[0] = etaBins;
  trackAxisTitle[0] = etaTitle;
  
  // delta eta
  Int_t nDeltaEtaBins = -1;
  Double_t* deltaEtaBins = GetBinning(binning, "delta_eta", nDeltaEtaBins);

  // pT
  trackBins[1] = GetBinning(binning, "p_t_assoc", iTrackBin[1]);
  trackAxisTitle[1] = "p_{T} (GeV/c)";
  
  // pT, fine
  Int_t npTBinsFine = -1;
  Double_t* pTBinsFine = GetBinning(binning, "p_t_eff", npTBinsFine);

  // pT,lead binning 1
  Int_t nLeadingpTBins = -1;
  Double_t* leadingpTBins = GetBinning(binning, "p_t_leading", nLeadingpTBins);

  // pT,lead binning 2
  Int_t nLeadingpTBins2 = -1;
  Double_t* leadingpTBins2 = GetBinning(binning, "p_t_leading_course", nLeadingpTBins2);
  
  // phi,lead
  Int_t nLeadingPhiBins = -1;
  Double_t* leadingPhiBins = GetBinning(binning, "delta_phi", nLeadingPhiBins);
  
  trackBins[3] = GetBinning(binning, "multiplicity", iTrackBin[3]);
  trackAxisTitle[3] = "multiplicity";
  
  // particle species
  const Int_t kNSpeciesBins = 4; // pi, K, p, rest
  Double_t speciesBins[] = { -0.5, 0.5, 1.5, 2.5, 3.5 };
  
  // vtx-z axis
  const char* vertexTitle = "z-vtx (cm)";
  Int_t nVertexBins = -1;
  Double_t* vertexBins = GetBinning(binning, "vertex", nVertexBins);
  Int_t nVertexBinsEff = -1;
  Double_t* vertexBinsEff = GetBinning(binning, "vertex_eff", nVertexBinsEff);
  
  Int_t useVtxAxis = 0;
  
  // selection depending on requested histogram
  Int_t axis = -1; // 0 = pT,lead, 1 = phi,lead
  if (strcmp(reqHist, "NumberDensitypT") == 0)
  {
    axis = 0;
    title = "d^{2}N_{ch}/d#varphid#eta";
  }
  else if (strcmp(reqHist, "NumberDensityPhi") == 0)
  {
    axis = 1;
    title = "d^{2}N_{ch}/d#varphid#eta";
  }
  else if (TString(reqHist).BeginsWith("NumberDensityPhiCentrality"))
  {
    if (TString(reqHist).Contains("Vtx"))
      useVtxAxis = 1;
    
    reqHist = "NumberDensityPhiCentrality";
    fHistogramType = reqHist;
    axis = 2;
    title = "d^{2}N_{ch}/d#varphid#eta";
  }
  else if (strcmp(reqHist, "SumpT") == 0)
  {
    axis = 0;
    title = "d^{2}#Sigma p_{T}/d#varphid#eta";
  }
  else if (TString(reqHist).BeginsWith("TwoPlusOne"))
  { 
    useVtxAxis = 1;

    reqHist = "TwoPlusOne";
    fHistogramType = reqHist;
    axis = 3;
    title = "d^{2}N_{ch}/d#varphid#eta";
  }
  else
    AliFatal(Form("Invalid histogram requested: %s", reqHist));
  
  UInt_t initRegions = fkRegions;
  
  if (axis == 0)
  {
    trackBins[2] = leadingpTBins;
    iTrackBin[2] = nLeadingpTBins;
    trackAxisTitle[2] = "leading p_{T} (GeV/c)";
    
  }
  else if (axis == 1)
  {
    nTrackVars = 5;
    initRegions = 1;
  
    iTrackBin[2] = nLeadingpTBins2;
    trackBins[2] = leadingpTBins2;
    trackAxisTitle[2] = "leading p_{T} (GeV/c)";
    
    iTrackBin[4] = nLeadingPhiBins;
    trackBins[4] = leadingPhiBins;
    trackAxisTitle[4] = "#Delta #varphi w.r.t. leading track";
  }
  else if (axis == 2)
  {
    nTrackVars = 5;
    initRegions = 1;
  
    iTrackBin[0] = nDeltaEtaBins;
    trackBins[0] = deltaEtaBins;
    trackAxisTitle[0] = "#Delta#eta";
  
    iTrackBin[2] = nLeadingpTBins2;
    trackBins[2] = leadingpTBins2;
    trackAxisTitle[2] = "leading p_{T} (GeV/c)";
    
    trackAxisTitle[3] = "centrality";
  
    iTrackBin[4] = nLeadingPhiBins;
    trackBins[4] = leadingPhiBins;
    trackAxisTitle[4] = "#Delta#varphi (rad)";

    if (useVtxAxis > 0)
    {
      nTrackVars = 6;
      iTrackBin[5] = nVertexBins;
      trackBins[5] = vertexBins;
      trackAxisTitle[5] = vertexTitle;
    }
  }
  else if (axis == 3)
  {
    nTrackVars = 7;
    initRegions = 1;

    iTrackBin[0] = nDeltaEtaBins;
    trackBins[0] = deltaEtaBins;
    trackAxisTitle[0] = "#Delta#eta";
  
    iTrackBin[2] = nLeadingpTBins;
    trackBins[2] = leadingpTBins;
    trackAxisTitle[2] = "Trigger 1 p_{T} (GeV/c)";
    
    trackAxisTitle[3] = "centrality";
  
    iTrackBin[4] = nLeadingPhiBins;
    trackBins[4] = leadingPhiBins;
    trackAxisTitle[4] = "#Delta#varphi (rad)";

    iTrackBin[5] = nVertexBins;
    trackBins[5] = vertexBins;
    trackAxisTitle[5] = vertexTitle;

    iTrackBin[6] = nLeadingpTBins2;
    trackBins[6] = leadingpTBins2;
    trackAxisTitle[6] = "Trigger 2 p_{T} (GeV/c)";
  }
    
  for (UInt_t i=0; i<initRegions; i++)
  {
    if (axis >= 2)
      fTrackHist[i] = new AliTHn(Form("fTrackHist_%d", i), title, fgkCFSteps, nTrackVars, iTrackBin);
    else
      fTrackHist[i] = new AliCFContainer(Form("fTrackHist_%d", i), title, fgkCFSteps, nTrackVars, iTrackBin);
    
    for (Int_t j=0; j<nTrackVars; j++)
    {
      fTrackHist[i]->SetBinLimits(j, trackBins[j]);
      fTrackHist[i]->SetVarTitle(j, trackAxisTitle[j]);
    }
    
    SetStepNames(fTrackHist[i]);
  }
  
  // event level
  Int_t nEventVars = 2;
  Int_t iEventBin[4];

  // track 3rd and 4th axis --> event 1st and 2nd axis
  iEventBin[0] = iTrackBin[2];
  iEventBin[1] = iTrackBin[3];
  
  // plus track 5th axis (in certain cases)
  if (axis >= 2 && useVtxAxis)
  {
    nEventVars = 3;
    iEventBin[2] = iTrackBin[5];
  }
  if (axis >= 3)
  {
    nEventVars = 4;
    iEventBin[3] = iTrackBin[6];
  }
  fEventHist = new AliCFContainer("fEventHist", title, fgkCFSteps, nEventVars, iEventBin);
  
  fEventHist->SetBinLimits(0, trackBins[2]);
  fEventHist->SetVarTitle(0, trackAxisTitle[2]);
  
  fEventHist->SetBinLimits(1, trackBins[3]);
  fEventHist->SetVarTitle(1, trackAxisTitle[3]);
  
  if (axis >= 2 && useVtxAxis)
  {
    fEventHist->SetBinLimits(2, trackBins[5]);
    fEventHist->SetVarTitle(2, trackAxisTitle[5]);
  }
  if (axis >= 3)
  {
    fEventHist->SetBinLimits(3, trackBins[6]);
    fEventHist->SetVarTitle(3, trackAxisTitle[6]);
  }

  SetStepNames(fEventHist);
  
  iTrackBin[0] = nEtaBins;
  iTrackBin[1] = npTBinsFine;
  iTrackBin[2] = kNSpeciesBins;
  iTrackBin[4] = nVertexBinsEff;

  fTrackHistEfficiency = new AliCFContainer("fTrackHistEfficiency", "Tracking efficiency", 6, 5, iTrackBin);
  fTrackHistEfficiency->SetBinLimits(0, etaBins);
  fTrackHistEfficiency->SetVarTitle(0, etaTitle);
  fTrackHistEfficiency->SetBinLimits(1, pTBinsFine);
  fTrackHistEfficiency->SetVarTitle(1, trackAxisTitle[1]);
  fTrackHistEfficiency->SetBinLimits(2, speciesBins);
  fTrackHistEfficiency->SetVarTitle(2, "particle species");
  fTrackHistEfficiency->SetBinLimits(3, trackBins[3]);
  fTrackHistEfficiency->SetVarTitle(3, trackAxisTitle[3]);
  fTrackHistEfficiency->SetBinLimits(4, vertexBinsEff);
  fTrackHistEfficiency->SetVarTitle(4, vertexTitle);

  fFakePt = new TH3F("fFakePt","fFakePt;p_{T,rec};p_{T};centrality", 200, 0, 20, 200, 0, 20, 20, 0, 100);
  
  delete[] deltaEtaBins;
  delete[] pTBinsFine;
  delete[] leadingpTBins;
  delete[] leadingpTBins2;
  delete[] leadingPhiBins;
  delete[] vertexBins;
  delete[] vertexBinsEff;
}
  
TString AliUEHist::CombineBinning(TString defaultBinning, TString customBinning) 
{
  // combine default binning with custom binning
  // replaces binnings in default binning if it is defined in custom binning
  
  TString binningStr;

  TObjArray* lines = defaultBinning.Tokenize("\n");
  for (Int_t i=0; i<lines->GetEntriesFast(); i++)
  {
    TString line(lines->At(i)->GetName());
    TString tag = line(0, line.Index(":")+1);
    if (!customBinning.BeginsWith(tag) && !customBinning.Contains(TString("\n") + tag))
      binningStr += line + "\n";
    else
      Printf("Using custom binning for %s", tag.Data());
  }
  delete lines;
  binningStr += customBinning;
  
  return binningStr;
}
  
Double_t* AliUEHist::GetBinning(const char* configuration, const char* tag, Int_t& nBins)
{
  // takes the binning from <configuration> identified by <tag>
  // configuration syntax example:
  // eta: 2.4, -2.3, -2.2, -2.1, -2.0, -1.9, -1.8, -1.7, -1.6, -1.5, -1.4, -1.3, -1.2, -1.1, -1.0, -0.9, -0.8, -0.7, -0.6, -0.5, -0.4, -0.3, -0.2, -0.1, 0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2.0, 2.1, 2.2, 2.3, 2.4
  // phi: .....
  //
  // returns bin edges which have to be deleted by the caller
  
  TString config(configuration);
  TObjArray* lines = config.Tokenize("\n");
  for (Int_t i=0; i<lines->GetEntriesFast(); i++)
  {
    TString line(lines->At(i)->GetName());
    if (line.BeginsWith(TString(tag) + ":"))
    {
      line.Remove(0, strlen(tag) + 1);
      line.ReplaceAll(" ", "");
      TObjArray* binning = line.Tokenize(",");
      Double_t* bins = new Double_t[binning->GetEntriesFast()];
      for (Int_t j=0; j<binning->GetEntriesFast(); j++)
	bins[j] = TString(binning->At(j)->GetName()).Atof();
      
      nBins = binning->GetEntriesFast() - 1;

      delete binning;
      delete lines;
      return bins;
    }
  }
  
  delete lines;
  AliFatal(Form("Tag %s not found in %s", tag, configuration));
  return 0;
}

//_____________________________________________________________________________
AliUEHist::AliUEHist(const AliUEHist &c) :
  TObject(),
  fkRegions(4),
  fEventHist(0),
  fTrackHistEfficiency(0),
  fFakePt(0),
  fEtaMin(0),
  fEtaMax(0),
  fPtMin(0),
  fPtMax(0),
  fPartSpecies(-1),
  fCentralityMin(0),
  fCentralityMax(0),
  fZVtxMin(0),
  fZVtxMax(0),
  fPt2Min(0),
  fContaminationEnhancement(0),
  fCombineMinMax(0),
  fTrackEtaCut(0),
  fWeightPerEvent(0),
  fSkipScaleMixedEvent(kFALSE),
  fCache(0),
  fGetMultCacheOn(kFALSE),
  fGetMultCache(0),
  fHistogramType()
{
  //
  // AliUEHist copy constructor
  //

  ((AliUEHist &) c).Copy(*this);
}

//____________________________________________________________________
void AliUEHist::SetStepNames(AliCFContainer* container)
{
  // sets the names of the correction steps
  
  for (Int_t i=0; i<fgkCFSteps; i++)
    container->SetStepTitle(i, GetStepTitle((CFStep) i));
}

//____________________________________________________________________
AliUEHist::~AliUEHist()
{
  // Destructor
  
  for (UInt_t i=0; i<fkRegions; i++)
  {
    if (fTrackHist[i])
    {
      delete fTrackHist[i];
      fTrackHist[i] = 0;
    }
  }
     
  if (fEventHist)
  {
    delete fEventHist;
    fEventHist = 0;
  }
  
  if (fTrackHistEfficiency)
  {
    delete fTrackHistEfficiency;
    fTrackHistEfficiency = 0;
  }

  if (fFakePt)
  {
    delete fFakePt;
    fFakePt = 0;
  }

  if (fCache)
  {
    delete fCache;
    fCache = 0;
  }
}

//____________________________________________________________________
AliUEHist &AliUEHist::operator=(const AliUEHist &c)
{
  // assigment operator

  if (this != &c)
    ((AliUEHist &) c).Copy(*this);

  return *this;
}

//____________________________________________________________________
void AliUEHist::Copy(TObject& c) const
{
  // copy function

  AliUEHist& target = (AliUEHist &) c;

  for (UInt_t i=0; i<fkRegions; i++)
    if (fTrackHist[i])
      target.fTrackHist[i] = dynamic_cast<AliCFContainer*> (fTrackHist[i]->Clone());

  if (fEventHist)
    target.fEventHist = dynamic_cast<AliCFContainer*> (fEventHist->Clone());
  
  if (fTrackHistEfficiency)
    target.fTrackHistEfficiency = dynamic_cast<AliCFContainer*> (fTrackHistEfficiency->Clone());
    
  if (fFakePt)
    target.fFakePt = dynamic_cast<TH3F*> (fFakePt->Clone());

  target.fEtaMin = fEtaMin;
  target.fEtaMax = fEtaMax;
  target.fPtMin = fPtMin;
  target.fPtMax = fPtMax;
  target.fPartSpecies = fPartSpecies;
  target.fCentralityMin = fCentralityMin;
  target.fCentralityMax = fCentralityMax;
  target.fZVtxMin = fZVtxMin;
  target.fZVtxMax = fZVtxMax;
  target.fPt2Min = fPt2Min;
  
  if (fContaminationEnhancement)
    target.fContaminationEnhancement = dynamic_cast<TH1F*> (fContaminationEnhancement->Clone());
    
  target.fCombineMinMax = fCombineMinMax;
  target.fTrackEtaCut = fTrackEtaCut;
  target.fWeightPerEvent = fWeightPerEvent;
  target.fSkipScaleMixedEvent = fSkipScaleMixedEvent;
  target.fHistogramType = fHistogramType;
}

//____________________________________________________________________
Long64_t AliUEHist::Merge(TCollection* list)
{
  // Merge a list of AliUEHist 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 objects
  const UInt_t kMaxLists = fkRegions+3;
  TList** lists = new TList*[kMaxLists];
  
  for (UInt_t i=0; i<kMaxLists; i++)
    lists[i] = new TList;
  
  Int_t count = 0;
  while ((obj = iter->Next())) {
    
    AliUEHist* entry = dynamic_cast<AliUEHist*> (obj);
    if (entry == 0) 
      continue;

    for (UInt_t i=0; i<fkRegions; i++)
      if (entry->fTrackHist[i])
        lists[i]->Add(entry->fTrackHist[i]);
    
    lists[fkRegions]->Add(entry->fEventHist);
    lists[fkRegions+1]->Add(entry->fTrackHistEfficiency);
    if (entry->fFakePt)
      lists[fkRegions+2]->Add(entry->fFakePt);

    count++;
  }
  for (UInt_t i=0; i<fkRegions; i++)
    if (fTrackHist[i])
      fTrackHist[i]->Merge(lists[i]);
  
  fEventHist->Merge(lists[fkRegions]);
  fTrackHistEfficiency->Merge(lists[fkRegions+1]);
  if (fFakePt)
    fFakePt->Merge(lists[fkRegions+2]);

  for (UInt_t i=0; i<kMaxLists; i++)
    delete lists[i];
    
  delete[] lists;

  return count+1;
}

//____________________________________________________________________
void AliUEHist::SetBinLimits(THnBase* grid)
{
  // sets the bin limits in eta and pT defined by fEtaMin/Max, fPtMin/Max
  
  if (fEtaMax > fEtaMin)
    grid->GetAxis(0)->SetRangeUser(fEtaMin, fEtaMax);
  if (fPtMax > fPtMin)
    grid->GetAxis(1)->SetRangeUser(fPtMin, fPtMax);
  if (fPt2Min > 0)
    grid->GetAxis(6)->SetRangeUser(fPt2Min, grid->GetAxis(6)->GetXmax() - 0.01);
}  

//____________________________________________________________________
void AliUEHist::SetBinLimits(AliCFGridSparse* grid)
{
  // sets the bin limits in eta and pT defined by fEtaMin/Max, fPtMin/Max
  
  SetBinLimits(grid->GetGrid());
}

//____________________________________________________________________
void AliUEHist::ResetBinLimits(THnBase* grid)
{
  // resets all bin limits 

  for (Int_t i=0; i<grid->GetNdimensions(); i++)
    if (grid->GetAxis(i)->TestBit(TAxis::kAxisRange))
      grid->GetAxis(i)->SetRangeUser(0, -1);
}

//____________________________________________________________________
void AliUEHist::ResetBinLimits(AliCFGridSparse* grid)
{
  // resets all bin limits 
  
  ResetBinLimits(grid->GetGrid());
}

//____________________________________________________________________
void AliUEHist::CountEmptyBins(AliUEHist::CFStep step, Float_t ptLeadMin, Float_t ptLeadMax)
{
  // prints the number of empty bins in the track end event histograms in the given step
  
  Int_t binBegin[4];
  Int_t binEnd[4];
  
  for (Int_t i=0; i<4; i++)
  {
    binBegin[i] = 1;
    binEnd[i]   = fTrackHist[0]->GetNBins(i);
  }
  
  if (fEtaMax > fEtaMin)
  {
    binBegin[0] = fTrackHist[0]->GetGrid(step)->GetGrid()->GetAxis(0)->FindBin(fEtaMin);
    binEnd[0]   = fTrackHist[0]->GetGrid(step)->GetGrid()->GetAxis(0)->FindBin(fEtaMax);
  }
  
  if (fPtMax > fPtMin)
  {
    binBegin[1] = fTrackHist[0]->GetGrid(step)->GetGrid()->GetAxis(1)->FindBin(fPtMin);
    binEnd[1]   = fTrackHist[0]->GetGrid(step)->GetGrid()->GetAxis(1)->FindBin(fPtMax);
  }
  
  if (ptLeadMax > ptLeadMin)
  {
    binBegin[2] = fTrackHist[0]->GetGrid(step)->GetGrid()->GetAxis(2)->FindBin(ptLeadMin);
    binEnd[2]   = fTrackHist[0]->GetGrid(step)->GetGrid()->GetAxis(2)->FindBin(ptLeadMax);
  }
  
  // start from multiplicity 1
  binBegin[3] = fTrackHist[0]->GetGrid(step)->GetGrid()->GetAxis(3)->FindBin(1);
  
  for (UInt_t region=0; region<fkRegions; region++)
  {
    Int_t total = 0;
    Int_t count = 0;
    Int_t vars[4];
    
    for (Int_t i=0; i<4; i++)
      vars[i] = binBegin[i];
      
    AliCFGridSparse* grid = fTrackHist[region]->GetGrid(step);
    while (1)
    {
      if (grid->GetElement(vars) == 0)
      {
        Printf("Empty bin at eta=%.2f pt=%.2f pt_lead=%.2f mult=%.1f", 
          grid->GetBinCenter(0, vars[0]), 
          grid->GetBinCenter(1, vars[1]), 
          grid->GetBinCenter(2, vars[2]), 
          grid->GetBinCenter(3, vars[3])
        );
        count++;
      }
      
      vars[3]++;
      for (Int_t i=3; i>0; i--)
      {
        if (vars[i] == binEnd[i]+1)
        {
          vars[i] = binBegin[i];
          vars[i-1]++;
        }
      }
      
      if (vars[0] == binEnd[0]+1)
        break;
      total++;
    }
  
    Printf("Region %s has %d empty bins (out of %d bins)", GetRegionTitle((Region) region), count, total);
  }
}  

//____________________________________________________________________
TH1* AliUEHist::GetUEHist(AliUEHist::CFStep step, AliUEHist::Region region, Float_t ptLeadMin, Float_t ptLeadMax, Int_t multBinBegin, Int_t multBinEnd, Int_t twoD, Bool_t etaNorm, Long64_t* normEvents)
{
  // Extracts the UE histogram at the given step and in the given region by projection and dividing tracks by events
  //
  // ptLeadMin, ptLeadMax: Only meaningful for vs. delta phi plot (third axis is ptLead)
  // Histogram has to be deleted by the caller of the function
  //
  // twoD: 0: 1D histogram as function of phi
  //       1: 2D histogram, deltaphi, deltaeta
  //       10: 1D histogram, within |deltaeta| < 0.8
  //       11: 1D histogram, within 0.8 < |deltaeta| < 1.6
  //
  // etaNorm: if kTRUE (default), the distributions are divided by the area in delta eta
  //
  // normEvents: if non-0 the number of events/trigger particles for the normalization is filled
  
  // unzoom all axes
  ResetBinLimits(fTrackHist[region]->GetGrid(step));
  ResetBinLimits(fEventHist->GetGrid(step));
  
  SetBinLimits(fTrackHist[region]->GetGrid(step));
  
  // z vtx
  if (fZVtxMax > fZVtxMin)
  {
    Printf("Using z-vtx range %f --> %f", fZVtxMin, fZVtxMax);
    fTrackHist[region]->GetGrid(step)->GetGrid()->GetAxis(5)->SetRangeUser(fZVtxMin, fZVtxMax);
    fEventHist->GetGrid(step)->GetGrid()->GetAxis(2)->SetRangeUser(fZVtxMin, fZVtxMax);
  }
    
  TH1D* tracks = 0;
  
  if (ptLeadMin < 0)
  {
    tracks = fTrackHist[region]->ShowProjection(2, step);
    tracks->GetYaxis()->SetTitle(fTrackHist[region]->GetTitle());
    if (fCombineMinMax && region == kMin)
    {
      ResetBinLimits(fTrackHist[kMax]->GetGrid(step));
      SetBinLimits(fTrackHist[kMax]->GetGrid(step));
      
      TH1D* tracks2 = fTrackHist[kMax]->ShowProjection(2, step);
      tracks->Add(tracks2);
      
      ResetBinLimits(fTrackHist[kMax]->GetGrid(step));
    }
      
    // normalize to get a density (deta dphi)
    TAxis* axis = fTrackHist[region]->GetGrid(step)->GetAxis(0);
    Float_t phiRegion = TMath::TwoPi() / 3;
    if (!fCombineMinMax && region == kMin)
      phiRegion /= 2;
    Float_t normalization = phiRegion;
    if (etaNorm)
      normalization *= (axis->GetBinUpEdge(axis->GetLast()) - axis->GetBinLowEdge(axis->GetFirst()));
    //Printf("Normalization: %f", normalization);
    tracks->Scale(1.0 / normalization);
    
    TH1D* events = fEventHist->ShowProjection(0, step);
    tracks->Divide(events);
  }
  else
  {
    if (multBinEnd >= multBinBegin)
    {
      Printf("Using multiplicity range %d --> %d", multBinBegin, multBinEnd);
      fTrackHist[region]->GetGrid(step)->GetGrid()->GetAxis(3)->SetRange(multBinBegin, multBinEnd);
      fEventHist->GetGrid(step)->GetGrid()->GetAxis(1)->SetRange(multBinBegin, multBinEnd);
    }
    
    Int_t firstBin = fTrackHist[region]->GetAxis(2, step)->FindBin(ptLeadMin);
    Int_t lastBin = fTrackHist[region]->GetAxis(2, step)->FindBin(ptLeadMax);
    
    Printf("Using leading pT range %d --> %d", firstBin, lastBin);
    
    fTrackHist[region]->GetGrid(step)->GetGrid()->GetAxis(2)->SetRange(firstBin, lastBin);
    
    if (twoD == 0)
      tracks = (TH1D*) fTrackHist[region]->GetGrid(step)->Project(4);
    else
      tracks = (TH1D*) fTrackHist[region]->GetGrid(step)->Project(4, 0);
      
    Printf("Calculated histogram --> %f tracks", tracks->Integral());
    fTrackHist[region]->GetGrid(step)->SetRangeUser(2, 0, -1);
    
    if (twoD == 10 || twoD == 11)
    {
      Float_t etaLimit = 1.0;
      if (twoD == 10)
      {
        tracks = (TH1D*) ((TH2*) tracks)->ProjectionX("proj", tracks->GetYaxis()->FindBin(-etaLimit + 0.01), tracks->GetYaxis()->FindBin(etaLimit - 0.01))->Clone();
        
        // TODO calculate acc with 2 * (deta - 0.5 * deta*deta / 1.6)
        tracks->Scale(1. / 0.75);
      }
      else if (twoD == 11)
      {
        TH1D* tracksTmp1 = (TH1D*) ((TH2*) tracks)->ProjectionX("proj1", tracks->GetYaxis()->FindBin(-etaLimit * 2 + 0.01), tracks->GetYaxis()->FindBin(-etaLimit - 0.01))->Clone();
        TH1D* tracksTmp2 = ((TH2*) tracks)->ProjectionX("proj2", tracks->GetYaxis()->FindBin(etaLimit + 0.01), tracks->GetYaxis()->FindBin(2 * etaLimit - 0.01));
        
        tracksTmp1->Add(tracksTmp2);
        
        delete tracks;
        tracks = tracksTmp1;
        delete tracksTmp2;
        
        tracks->Scale(1. / 0.25);
      }
    }
    
    // normalize to get a density (deta dphi)
    // TODO normalization may be off for 2d histogram
    Float_t normalization = fTrackHist[region]->GetGrid(step)->GetAxis(4)->GetBinWidth(1);
    
    if (etaNorm)
    {
      TAxis* axis = fTrackHist[region]->GetGrid(step)->GetAxis(0);
      if (strcmp(axis->GetTitle(), "#eta") == 0)
      {
	Printf("Normalizing using eta-axis range");
	normalization *= axis->GetBinUpEdge(axis->GetLast()) - axis->GetBinLowEdge(axis->GetFirst());
      }
      else
      {
	Printf("Normalizing assuming accepted range of |eta| < 0.8");
	normalization *= 0.8 * 2;
      }
    }
    
    //Printf("Normalization: %f", normalization);
    tracks->Scale(1.0 / normalization);
    
    // NOTE fEventHist contains the number of events for the underlying event analysis and the number of trigger particles for the azimuthal correlation analysis. In the latter case the naming is therefore somewhat misleading!
    TH1D* events = fEventHist->ShowProjection(0, step);
    Long64_t nEvents = (Long64_t) events->Integral(firstBin, lastBin);
    Printf("Calculated histogram --> %lld events", nEvents);
    if (normEvents)
      *normEvents = nEvents;
      
    if (nEvents > 0)
      tracks->Scale(1.0 / nEvents);
    
    delete events;
  }

  ResetBinLimits(fTrackHist[region]->GetGrid(step));
  ResetBinLimits(fEventHist->GetGrid(step));

  return tracks;
}

//____________________________________________________________________
void AliUEHist::GetHistsZVtx(AliUEHist::CFStep step, AliUEHist::Region region, Float_t ptLeadMin, Float_t ptLeadMax, Int_t multBinBegin, Int_t multBinEnd, TH3** trackHist, TH1** eventHist)
{
  // Calculates a 3d histogram with deltaphi, deltaeta, zvtx on track level and a 1d histogram on event level (as fct of zvtx)
  // Histogram has to be deleted by the caller of the function
  
  if (!fTrackHist[kToward]->GetGrid(0)->GetGrid()->GetAxis(5))
    AliFatal("Histogram without vertex axis provided");

  // unzoom all axes
  ResetBinLimits(fTrackHist[region]->GetGrid(step));
  ResetBinLimits(fEventHist->GetGrid(step));
  
  SetBinLimits(fTrackHist[region]->GetGrid(step));
  
  if (multBinEnd >= multBinBegin)
  {
    Printf("Using multiplicity range %d --> %d", multBinBegin, multBinEnd);
    fTrackHist[region]->GetGrid(step)->GetGrid()->GetAxis(3)->SetRange(multBinBegin, multBinEnd);
    fEventHist->GetGrid(step)->GetGrid()->GetAxis(1)->SetRange(multBinBegin, multBinEnd);
  }
    
  Int_t firstBin = fTrackHist[region]->GetAxis(2, step)->FindBin(ptLeadMin);
  Int_t lastBin = fTrackHist[region]->GetAxis(2, step)->FindBin(ptLeadMax);
  Printf("Using leading pT range %d --> %d", firstBin, lastBin);
  fTrackHist[region]->GetGrid(step)->GetGrid()->GetAxis(2)->SetRange(firstBin, lastBin);
  fEventHist->GetGrid(step)->GetGrid()->GetAxis(0)->SetRange(firstBin, lastBin);
    
  *trackHist = (TH3*) fTrackHist[region]->GetGrid(step)->Project(4, 0, 5);
  *eventHist = (TH1*) fEventHist->GetGrid(step)->Project(2);

  ResetBinLimits(fTrackHist[region]->GetGrid(step));
  ResetBinLimits(fEventHist->GetGrid(step));
}

//____________________________________________________________________
void AliUEHist::GetHistsZVtxMult(AliUEHist::CFStep step, AliUEHist::Region region, Float_t ptLeadMin, Float_t ptLeadMax, THnBase** trackHist, TH2** eventHist)
{
  // Calculates a 4d histogram with deltaphi, deltaeta, zvtx, multiplicity on track level and 
  // a 2d histogram on event level (as fct of zvtx, multiplicity)
  // Histograms has to be deleted by the caller of the function
  
  if (!fTrackHist[kToward]->GetGrid(0)->GetGrid()->GetAxis(5))
    AliFatal("Histogram without vertex axis provided");

  THnBase* sparse = fTrackHist[region]->GetGrid(step)->GetGrid();
  if (fGetMultCacheOn)
  {
    if (!fGetMultCache)
    {
      fGetMultCache = ChangeToThn(sparse);
      // should work but causes SEGV in ProjectionND below 
    }
    sparse = fGetMultCache;
  }
  
  // unzoom all axes
  ResetBinLimits(sparse);
  ResetBinLimits(fEventHist->GetGrid(step));
  
  SetBinLimits(sparse);
  
  Int_t firstBin = sparse->GetAxis(2)->FindBin(ptLeadMin);
  Int_t lastBin = sparse->GetAxis(2)->FindBin(ptLeadMax);
  Printf("Using leading pT range %d --> %d", firstBin, lastBin);
  sparse->GetAxis(2)->SetRange(firstBin, lastBin);
  fEventHist->GetGrid(step)->GetGrid()->GetAxis(0)->SetRange(firstBin, lastBin);

  // cut on the second trigger particle if there is a minimum set
  if (fPt2Min > 0)
  {
    Int_t firstBinPt2 = sparse->GetAxis(6)->FindBin(fPt2Min);
    Int_t lastBinPt2 = sparse->GetAxis(6)->GetNbins();

    fEventHist->GetGrid(step)->GetGrid()->GetAxis(3)->SetRange(firstBinPt2, lastBinPt2);
  }
    
  Int_t dimensions[] = { 4, 0, 5, 3 };
  THnBase* tmpTrackHist = sparse->ProjectionND(4, dimensions, "E");
  *eventHist = (TH2*) fEventHist->GetGrid(step)->Project(2, 1);
  
  ResetBinLimits(sparse);
  ResetBinLimits(fEventHist->GetGrid(step));

  // convert to THn 
  *trackHist = ChangeToThn(tmpTrackHist);
  delete tmpTrackHist;
}

//____________________________________________________________________
TH2* AliUEHist::GetSumOfRatios2(AliUEHist* mixed, AliUEHist::CFStep step, AliUEHist::Region region, Float_t ptLeadMin, Float_t ptLeadMax, Int_t multBinBegin, Int_t multBinEnd, Bool_t normalizePerTrigger, Int_t stepForMixed, Int_t* trigger)
{
  // Calls GetUEHist(...) for *each* vertex bin and multiplicity bin and performs a sum of ratios:
  // 1_N [ (same/mixed)_1 + (same/mixed)_2 + (same/mixed)_3 + ... ]
  // where N is the total number of events/trigger particles and the subscript is the vertex/multiplicity bin
  // where mixed is normalized such that the information about the number of pairs in same is kept
  //
  // returns a 2D histogram: deltaphi, deltaeta
  //
  // Parameters:
  //   mixed: AliUEHist containing mixed event corresponding to this object (the histograms are taken from step <stepForMixed> if defined otherwise from step <step>)
  //   <other parameters> : check documentation of AliUEHist::GetUEHist
  //  normalizePerTrigger: divide through number of triggers
  
  // do not add this hists to the directory
  Bool_t oldStatus = TH1::AddDirectoryStatus();
  TH1::AddDirectory(kFALSE);
  
  TH2* totalTracks = 0;
  
  THnBase* trackSameAll = 0;
  THnBase* trackMixedAll = 0;
  THnBase* trackMixedAllStep6 = 0;
  TH2* eventSameAll = 0;
  TH2* eventMixedAll = 0;
  TH2* eventMixedAllStep6 = 0;
  
  Long64_t totalEvents = 0;
  Int_t nCorrelationFunctions = 0;
  
  GetHistsZVtxMult(step, region, ptLeadMin, ptLeadMax, &trackSameAll, &eventSameAll);
  mixed->GetHistsZVtxMult((stepForMixed == -1) ? step : (CFStep) stepForMixed, region, ptLeadMin, ptLeadMax, &trackMixedAll, &eventMixedAll);
  
  // If we ask for histograms from step8 (TTR cut applied) there is a hole at 0,0; so this cannot be used for the
  // mixed-event normalization. If step6 is available, the normalization factor is read out from that one.
  // If step6 is not available we fallback to taking the normalization along all delta phi (WARNING requires a
  // flat delta phi distribution)
  if (stepForMixed == -1 && step == kCFStepBiasStudy && mixed->fEventHist->GetGrid(kCFStepReconstructed)->GetEntries() > 0 && !fSkipScaleMixedEvent)
  {
    Printf("Using mixed-event normalization factors from step %d", kCFStepReconstructed);
    mixed->GetHistsZVtxMult(kCFStepReconstructed, region, ptLeadMin, ptLeadMax, &trackMixedAllStep6, &eventMixedAllStep6);
  }
  
//   Printf("%f %f %f %f", trackSameAll->GetEntries(), eventSameAll->GetEntries(), trackMixedAll->GetEntries(), eventMixedAll->GetEntries());
  
//   TH1* normParameters = new TH1F("normParameters", "", 100, 0, 2);
  
//   trackSameAll->Dump();

  TAxis* multAxis = trackSameAll->GetAxis(3);

  if (multBinEnd < multBinBegin)
  {
    multBinBegin = 1;
    multBinEnd = multAxis->GetNbins();
  }
  
  for (Int_t multBin = TMath::Max(1, multBinBegin); multBin <= TMath::Min(multAxis->GetNbins(), multBinEnd); multBin++)
  {
    trackSameAll->GetAxis(3)->SetRange(multBin, multBin);
    trackMixedAll->GetAxis(3)->SetRange(multBin, multBin);
    if (trackMixedAllStep6)
      trackMixedAllStep6->GetAxis(3)->SetRange(multBin, multBin);

    Double_t mixedNorm = 1;
    Double_t mixedNormError = 0;

    if (!fSkipScaleMixedEvent)
    {
      // get mixed normalization correction factor: is independent of vertex bin if scaled with number of triggers
      TH2* tracksMixed = 0;
      if (trackMixedAllStep6)
      {
	trackMixedAllStep6->GetAxis(2)->SetRange(0, -1);
	tracksMixed = trackMixedAllStep6->Projection(1, 0, "E");
      }
      else
      {
	trackMixedAll->GetAxis(2)->SetRange(0, -1);
	tracksMixed = trackMixedAll->Projection(1, 0, "E");
      }
  //     Printf("%f", tracksMixed->Integral());
      Float_t binWidthEta = tracksMixed->GetYaxis()->GetBinWidth(1);
    
      if (stepForMixed == -1 && step == kCFStepBiasStudy && !trackMixedAllStep6)
      {
	// get mixed event normalization by assuming full acceptance at deta at 0 (integrate over dphi), excluding (0, 0)
	Float_t phiExclude = 0.41;
	mixedNorm = tracksMixed->IntegralAndError(1, tracksMixed->GetXaxis()->FindBin(-phiExclude)-1, tracksMixed->GetYaxis()->FindBin(-0.01), tracksMixed->GetYaxis()->FindBin(0.01), mixedNormError);
	Double_t mixedNormError2 = 0;
	Double_t mixedNorm2 = tracksMixed->IntegralAndError(tracksMixed->GetXaxis()->FindBin(phiExclude)+1, tracksMixed->GetNbinsX(), tracksMixed->GetYaxis()->FindBin(-0.01), tracksMixed->GetYaxis()->FindBin(0.01), mixedNormError2);
      
	if (mixedNormError == 0 || mixedNormError2 == 0)
	{
	  Printf("ERROR: Skipping multiplicity %d because mixed event is empty %f %f %f %f", multBin, mixedNorm, mixedNormError, mixedNorm2, mixedNormError2);
	  continue;
	}
	
	Int_t nBinsMixedNorm = (tracksMixed->GetXaxis()->FindBin(-phiExclude) - 1 - 1 + 1) * (tracksMixed->GetYaxis()->FindBin(0.01) - tracksMixed->GetYaxis()->FindBin(-0.01) + 1);
	mixedNorm /= nBinsMixedNorm;
	mixedNormError /= nBinsMixedNorm;

	Int_t nBinsMixedNorm2 = (tracksMixed->GetNbinsX() - tracksMixed->GetXaxis()->FindBin(phiExclude) - 1 + 1) * (tracksMixed->GetYaxis()->FindBin(0.01) - tracksMixed->GetYaxis()->FindBin(-0.01) + 1);
	mixedNorm2 /= nBinsMixedNorm2;
	mixedNormError2 /= nBinsMixedNorm2;

	mixedNorm = mixedNorm / mixedNormError / mixedNormError + mixedNorm2 / mixedNormError2 / mixedNormError2;
	mixedNormError = TMath::Sqrt(1.0 / (1.0 / mixedNormError / mixedNormError + 1.0 / mixedNormError2 / mixedNormError2));
	mixedNorm *= mixedNormError * mixedNormError;
      }
      else
      {
	// get mixed event normalization at (0,0)
      
	mixedNorm = tracksMixed->IntegralAndError(tracksMixed->GetXaxis()->FindBin(-0.01), tracksMixed->GetXaxis()->FindBin(0.01), tracksMixed->GetYaxis()->FindBin(-0.01), tracksMixed->GetYaxis()->FindBin(0.01), mixedNormError);
	Int_t nBinsMixedNorm = (tracksMixed->GetXaxis()->FindBin(0.01) - tracksMixed->GetXaxis()->FindBin(-0.01) + 1) * (tracksMixed->GetYaxis()->FindBin(0.01) - tracksMixed->GetYaxis()->FindBin(-0.01) + 1);
	mixedNorm /= nBinsMixedNorm;
	mixedNormError /= nBinsMixedNorm;

	if (mixedNormError == 0)
	{
	  Printf("ERROR: Skipping multiplicity %d because mixed event is empty %f %f", multBin, mixedNorm, mixedNormError);
	  continue;
	}
      }

      // finite bin correction
      if (fTrackEtaCut > 0)
      {
	Double_t finiteBinCorrection = -1.0 / (2*fTrackEtaCut) * binWidthEta / 2 + 1;
	Printf("Finite bin correction: %f", finiteBinCorrection);
	mixedNorm /= finiteBinCorrection;
	mixedNormError /= finiteBinCorrection;
      }
      else
      {
	Printf("ERROR: fTrackEtaCut not set. Finite bin correction cannot be applied. Continuing anyway...");
      }

      Float_t triggers = eventMixedAll->Integral(1, eventMixedAll->GetNbinsX(), multBin, multBin);
//     Printf("%f +- %f | %f | %f", mixedNorm, mixedNormError, triggers, mixedNorm / triggers);
      if (triggers <= 0)
      {
	Printf("ERROR: Skipping multiplicity %d because mixed event is empty", multBin);
	continue;
      }
      
      mixedNorm /= triggers;
      mixedNormError /= triggers;      
      
      delete tracksMixed;
    }
    else
      Printf("WARNING: Skipping mixed-event scaling! fSkipScaleMixedEvent IS set!");

    if (mixedNorm <= 0)
    {
      Printf("ERROR: Skipping multiplicity %d because mixed event is empty at (0,0)", multBin);
      continue;
    }
    
//     Printf("Norm: %f +- %f", mixedNorm, mixedNormError);

//     normParameters->Fill(mixedNorm);
      
    TAxis* vertexAxis = trackSameAll->GetAxis(2);
    Int_t vertexBinBegin = 1;
    Int_t vertexBinEnd = vertexAxis->GetNbins();
    
    if (fZVtxMax > fZVtxMin)
    {
      vertexBinBegin = vertexAxis->FindBin(fZVtxMin);
      vertexBinEnd = vertexAxis->FindBin(fZVtxMax);
    }
    
    for (Int_t vertexBin = vertexBinBegin; vertexBin <= vertexBinEnd; vertexBin++)
    {
      trackSameAll->GetAxis(2)->SetRange(vertexBin, vertexBin);
      trackMixedAll->GetAxis(2)->SetRange(vertexBin, vertexBin);

      TH2* tracksSame = trackSameAll->Projection(1, 0, "E");
      TH2* tracksMixed = trackMixedAll->Projection(1, 0, "E");
      
      // asssume flat in dphi, gain in statistics
      //     TH1* histMixedproj = mixedTwoD->ProjectionY();
      //     histMixedproj->Scale(1.0 / mixedTwoD->GetNbinsX());
      //     
      //     for (Int_t x=1; x<=mixedTwoD->GetNbinsX(); x++)
      //       for (Int_t y=1; y<=mixedTwoD->GetNbinsY(); y++)
      // 	mixedTwoD->SetBinContent(x, y, histMixedproj->GetBinContent(y));

      //       delete histMixedproj;
      
      Float_t triggers2 = eventMixedAll->Integral(vertexBin, vertexBin, multBin, multBin);
      if (triggers2 <= 0)
      {
	Printf("ERROR: Skipping multiplicity %d vertex bin %d because mixed event is empty", multBin, vertexBin);
      }
      else
      {
	if (!fSkipScaleMixedEvent)
	  tracksMixed->Scale(1.0 / triggers2 / mixedNorm);
	else if (tracksMixed->Integral() > 0)
	  tracksMixed->Scale(1.0 / tracksMixed->Integral());
	// tracksSame->Scale(tracksMixed->Integral() / tracksSame->Integral());
	  
// 	new TCanvas; tracksSame->DrawClone("SURF1");
// 	new TCanvas; tracksMixed->DrawClone("SURF1");

	// some code to judge the relative contribution of the different correlation functions to the overall uncertainty
	Double_t sums[] = { 0, 0, 0 };
	Double_t errors[] = { 0, 0, 0 };

	for (Int_t x=1; x<=tracksSame->GetNbinsX(); x++)
	  for (Int_t y=1; y<=tracksSame->GetNbinsY(); y++)
	  {
	    sums[0] += tracksSame->GetBinContent(x, y);
	    errors[0] += tracksSame->GetBinError(x, y);
	    sums[1] += tracksMixed->GetBinContent(x, y);
	    errors[1] += tracksMixed->GetBinError(x, y);
	  }

	tracksSame->Divide(tracksMixed);
	  
	for (Int_t x=1; x<=tracksSame->GetNbinsX(); x++)
	  for (Int_t y=1; y<=tracksSame->GetNbinsY(); y++)
	  {
	    sums[2] += tracksSame->GetBinContent(x, y);
	    errors[2] += tracksSame->GetBinError(x, y);
	  }
	  
	for (Int_t x=0; x<3; x++)
	  if (sums[x] > 0)
	    errors[x] /= sums[x];
	  
	Printf("The correlation function %d %d has uncertainties %f %f %f (Ratio S/M %f)", multBin, vertexBin, errors[0], errors[1], errors[2], (errors[1] > 0) ? errors[0] / errors[1] : -1);
	// code to draw contributions
	/*
	TH1* proj = tracksSame->ProjectionX("projx", tracksSame->GetYaxis()->FindBin(-1.59), tracksSame->GetYaxis()->FindBin(1.59));
	proj->SetTitle(Form("Bin %d", vertexBin));
	proj->SetLineColor(vertexBin);
	proj->DrawCopy((vertexBin > 1) ? "SAME" : "");
	*/
	
	if (!totalTracks)
	  totalTracks = (TH2*) tracksSame->Clone("totalTracks");
	else
	  totalTracks->Add(tracksSame);

	totalEvents += eventSameAll->GetBinContent(vertexBin, multBin);
	
// 	new TCanvas; tracksMixed->DrawCopy("SURF1");
      }

      delete tracksSame;
      delete tracksMixed;
      
      nCorrelationFunctions++;
    }
  }

  if (totalTracks) {
    Double_t sums[] = { 0, 0, 0 };
    Double_t errors[] = { 0, 0, 0 };

    for (Int_t x=1; x<=totalTracks->GetNbinsX(); x++)
      for (Int_t y=1; y<=totalTracks->GetNbinsY(); y++)
      {
	sums[0] += totalTracks->GetBinContent(x, y);
	errors[0] += totalTracks->GetBinError(x, y);
      }
    if (sums[0] > 0)
      errors[0] /= sums[0];
    
    if (normalizePerTrigger)
    {
      Printf("Dividing %f tracks by %lld events (%d correlation function(s)) (error %f)", totalTracks->Integral(), totalEvents, nCorrelationFunctions, errors[0]);
      if (totalEvents > 0)
	totalTracks->Scale(1.0 / totalEvents);
    }
    if(trigger!=NULL)
      *trigger = (Int_t)totalEvents;
  
    // normalizate to dphi width
    Float_t normalization = totalTracks->GetXaxis()->GetBinWidth(1);
    totalTracks->Scale(1.0 / normalization);
  }
  
  delete trackSameAll;
  delete trackMixedAll;
  delete trackMixedAllStep6;
  delete eventSameAll;
  delete eventMixedAll;
  delete eventMixedAllStep6;
  
//   new TCanvas; normParameters->Draw();
  
  TH1::AddDirectory(oldStatus);
  
  return totalTracks;
}

TH1* AliUEHist::GetTriggersAsFunctionOfMultiplicity(AliUEHist::CFStep step, Float_t ptLeadMin, Float_t ptLeadMax)
{
  // returns the distribution of triggers as function of centrality/multiplicity

  ResetBinLimits(fEventHist->GetGrid(step));
  
  Int_t firstBin = fEventHist->GetGrid(step)->GetGrid()->GetAxis(0)->FindBin(ptLeadMin);
  Int_t lastBin = fEventHist->GetGrid(step)->GetGrid()->GetAxis(0)->FindBin(ptLeadMax);
  Printf("Using pT range %d --> %d", firstBin, lastBin);
  fEventHist->GetGrid(step)->GetGrid()->GetAxis(0)->SetRange(firstBin, lastBin);

  if (fZVtxMax > fZVtxMin)
  {
    fEventHist->GetGrid(step)->GetGrid()->GetAxis(2)->SetRangeUser(fZVtxMin, fZVtxMax);
    Printf("Restricting z-vtx: %f-%f", fZVtxMin, fZVtxMax);
  }
  
  TH1* eventHist = fEventHist->GetGrid(step)->Project(1);

  ResetBinLimits(fEventHist->GetGrid(step));
  
  return eventHist;  
}

/*
TH2* AliUEHist::GetPtDistInPhiRegion(AliUEHist* mixed, AliUEHist::CFStep step, AliUEHist::Region region, Float_t ptLeadMin, Float_t ptLeadMax, Int_t multBinBegin, Int_t multBinEnd, Float_t phiBegin, Float_t phiEnd)
{
  // Returns pT,assoc distribution in the given pt,trig, multiplicity, phi region
  // Does not use sum of ratios for mixed event correction (TODO to be improved)
  // returns a 2D histogram: deltaphi, deltaeta
  //
  // Parameters:
  //   mixed: AliUEHist containing mixed event corresponding to this object
*/

//____________________________________________________________________
TH2* AliUEHist::GetSumOfRatios(AliUEHist* mixed, AliUEHist::CFStep step, AliUEHist::Region region, Float_t ptLeadMin, Float_t ptLeadMax, Int_t multBinBegin, Int_t multBinEnd, Bool_t etaNorm, Bool_t useVertexBins)
{
  // Calls GetUEHist(...) for *each* multiplicity bin and performs a sum of ratios:
  // 1_N [ (same/mixed)_1 + (same/mixed)_2 + (same/mixed)_3 + ... ]
  // where N is the total number of events/trigger particles and the subscript is the multiplicity bin
  //
  // Can only be used for the 2D histogram at present
  //
  // Parameters:
  //   mixed: AliUEHist containing mixed event corresponding to this object
  //   <other parameters> : check documentation of AliUEHist::GetUEHist
  
  TH2* totalTracks = 0;
  Int_t totalEvents = 0;
  
  Int_t vertexBin = 1;
  TAxis* vertexAxis = fTrackHist[kToward]->GetGrid(0)->GetGrid()->GetAxis(5);
  if (useVertexBins && !vertexAxis)
  {
    Printf("Vertex axis requested but not available");
    return 0;
  }
  
  // vertex bin loop
  while (1)
  {
    if (useVertexBins)
    {
      SetZVtxRange(vertexAxis->GetBinLowEdge(vertexBin) + 0.01, vertexAxis->GetBinUpEdge(vertexBin) - 0.01);
      mixed->SetZVtxRange(vertexAxis->GetBinLowEdge(vertexBin) + 0.01, vertexAxis->GetBinUpEdge(vertexBin) - 0.01);
      vertexBin++;
    }
    
    // multiplicity loop
    Int_t multIter = multBinBegin;
    while (1)
    {
      Int_t multBinBeginLocal = multBinBegin;
      Int_t multBinEndLocal = multBinEnd;
      
      if (multBinEnd >= multBinBegin)
      {
	multBinBeginLocal = multIter;
	multBinEndLocal = multIter;
	multIter++;
      }
	
      Long64_t nEvents = 0;
      TH2* tracks = (TH2*) GetUEHist(step, region, ptLeadMin, ptLeadMax, multBinBeginLocal, multBinEndLocal, 1, etaNorm, &nEvents);
      // undo normalization
      tracks->Scale(nEvents);
      totalEvents += nEvents;
      
      TH2* mixedTwoD = (TH2*) mixed->GetUEHist(step, region, ptLeadMin, ptLeadMax, multBinBeginLocal, multBinEndLocal, 1, etaNorm);
      
      // asssume flat in dphi, gain in statistics
  //     TH1* histMixedproj = mixedTwoD->ProjectionY();
  //     histMixedproj->Scale(1.0 / mixedTwoD->GetNbinsX());
  //     
  //     for (Int_t x=1; x<=mixedTwoD->GetNbinsX(); x++)
  //       for (Int_t y=1; y<=mixedTwoD->GetNbinsY(); y++)
  // 	mixedTwoD->SetBinContent(x, y, histMixedproj->GetBinContent(y));

  //       delete histMixedproj;
  
      // get mixed event normalization by assuming full acceptance at deta of 0 (only works for flat dphi)
/*      Double_t mixedNorm = mixedTwoD->Integral(1, mixedTwoD->GetNbinsX(), mixedTwoD->GetYaxis()->FindBin(-0.01), mixedTwoD->GetYaxis()->FindBin(0.01));
      mixedNorm /= mixedTwoD->GetNbinsX() * (mixedTwoD->GetYaxis()->FindBin(0.01) - mixedTwoD->GetYaxis()->FindBin(-0.01) + 1);
      tracks->Scale(mixedNorm);*/
      
      tracks->Scale(mixedTwoD->Integral() / tracks->Integral());

      tracks->Divide(mixedTwoD);
      
      delete mixedTwoD;
      
      if (!totalTracks)
	totalTracks = tracks;
      else
      {
	totalTracks->Add(tracks);
	delete tracks;
      }

      if (multIter > multBinEnd)
	break;
    }
    
    if (!useVertexBins || vertexBin > vertexAxis->GetNbins())
      break;
  }

  if (useVertexBins)
    totalEvents = vertexAxis->GetNbins();

  Printf("Dividing %f tracks by %d events", totalTracks->Integral(), totalEvents);
  if (totalEvents > 0)
    totalTracks->Scale(1.0 / totalEvents);
  
  return totalTracks;
}

//____________________________________________________________________
TH1* AliUEHist::GetPtHist(CFStep step, Region region, Float_t ptLeadMin, Float_t ptLeadMax, Int_t multBinBegin, Int_t multBinEnd, Float_t phiMin, Float_t phiMax, Float_t etaMin, Float_t etaMax, Bool_t skipPhiNormalization)
{
  // returns a histogram projected to pT,assoc with the provided cuts
  
   // unzoom all axes
  ResetBinLimits(fTrackHist[region]->GetGrid(step));
  ResetBinLimits(fEventHist->GetGrid(step));
  
  TH1D* tracks = 0;
  
    // the efficiency to have find an event depends on leading pT and this is not corrected for because anyway per bin we calculate tracks over events
  // therefore the number density must be calculated here per leading pT bin and then summed

  if (multBinEnd > multBinBegin)
    Printf("Using multiplicity range %d --> %d", multBinBegin, multBinEnd);
  fTrackHist[region]->GetGrid(step)->GetGrid()->GetAxis(3)->SetRange(multBinBegin, multBinEnd);
  fEventHist->GetGrid(step)->GetGrid()->GetAxis(1)->SetRange(multBinBegin, multBinEnd);
  
  fTrackHist[region]->GetGrid(step)->GetGrid()->GetAxis(0)->SetRangeUser(etaMin, etaMax);
  fTrackHist[region]->GetGrid(step)->GetGrid()->GetAxis(4)->SetRangeUser(phiMin, phiMax);
  
  // get real phi cuts due to binning
  Float_t phiMinReal = fTrackHist[region]->GetGrid(step)->GetGrid()->GetAxis(4)->GetBinLowEdge(fTrackHist[region]->GetGrid(step)->GetGrid()->GetAxis(4)->GetFirst());
  Float_t phiMaxReal = fTrackHist[region]->GetGrid(step)->GetGrid()->GetAxis(4)->GetBinUpEdge(fTrackHist[region]->GetGrid(step)->GetGrid()->GetAxis(4)->GetLast());
  Printf("phi min = %.2f and max = %.2f requested; due to binning range will be from %.2f to %.2f, i.e. a %.0f%% larger window", phiMin, phiMax, phiMinReal, phiMaxReal, (phiMaxReal - phiMinReal) / (phiMax - phiMin) * 100 - 100);
  
  Int_t firstBin = fTrackHist[region]->GetAxis(2, step)->FindBin(ptLeadMin);
  Int_t lastBin = fTrackHist[region]->GetAxis(2, step)->FindBin(ptLeadMax);
  
  TH1D* events = fEventHist->ShowProjection(0, step);
  
  for (Int_t bin=firstBin; bin<=lastBin; bin++)
  {
    fTrackHist[region]->GetGrid(step)->GetGrid()->GetAxis(2)->SetRange(bin, bin);
    
    // project to pT,assoc
    TH1D* tracksTmp = (TH1D*) fTrackHist[region]->GetGrid(step)->Project(1);
    
    Printf("Calculated histogram in bin %d --> %f tracks", bin, tracksTmp->Integral());
    fTrackHist[region]->GetGrid(step)->SetRangeUser(2, 0, -1);
    
    // normalize to get a density (deta dphi)
    Float_t normalization = 1;
    TAxis* axis = fTrackHist[region]->GetGrid(step)->GetAxis(0);
    if (strcmp(axis->GetTitle(), "#eta") == 0)
    {
      Printf("Normalizing using eta-axis range");
      normalization *= axis->GetBinUpEdge(axis->GetLast()) - axis->GetBinLowEdge(axis->GetFirst());
    }
    else
    {
      Printf("Normalizating assuming accepted range of |eta| < 0.8");
      normalization *= 0.8 * 2;
    }
    
    // dphi
    if (!skipPhiNormalization)
      normalization *= phiMaxReal - phiMinReal;
    
    //Printf("Normalization: %f", normalization);
    tracksTmp->Scale(1.0 / normalization);
    
    // and now dpT (bins have different width)
    for (Int_t i=1; i<=tracksTmp->GetNbinsX(); i++)
    {
      tracksTmp->SetBinContent(i, tracksTmp->GetBinContent(i) / tracksTmp->GetXaxis()->GetBinWidth(i));
      tracksTmp->SetBinError  (i, tracksTmp->GetBinError(i) / tracksTmp->GetXaxis()->GetBinWidth(i));
    }
     
    Int_t nEvents = (Int_t) events->GetBinContent(bin);
    if (nEvents > 0)
      tracksTmp->Scale(1.0 / nEvents);
    Printf("Calculated histogram in bin %d --> %d events", bin, nEvents);
    
    if (!tracks)
      tracks = tracksTmp;
    else
    {
      tracks->Add(tracksTmp);
      delete tracksTmp;
    }
  }
  
  delete events;

  ResetBinLimits(fTrackHist[region]->GetGrid(step));
  ResetBinLimits(fEventHist->GetGrid(step));

  return tracks;
}

void AliUEHist::MultiplyHistograms(THnSparse* grid, THnSparse* target, TH1* histogram, Int_t var1, Int_t var2)
{
  // multiplies <grid> with <histogram> and put the result in <target>
  // <grid> has usually more dimensions than histogram. The axis which are used to choose the value 
  // from <histogram> are given in <var1> and <var2>
  //
  // if <histogram> is 0, just copies content from step1 to step2
  
  // clear target histogram
  if (grid != target)
    target->Reset();
  
  if (histogram != 0)
  {
    if (grid->GetAxis(var1)->GetNbins() != histogram->GetNbinsX())
      AliFatal(Form("Invalid binning (var1): %d %d", grid->GetAxis(var1)->GetNbins(), histogram->GetNbinsX()));
      
    if (var2 >= 0 && grid->GetAxis(var2)->GetNbins() != histogram->GetNbinsY())
      AliFatal(Form("Invalid binning (var2): %d %d", grid->GetAxis(var2)->GetNbins(), histogram->GetNbinsY()));
  }

  if (grid->GetNdimensions() > 6)
    AliFatal("Too many dimensions in THnSparse");
  
  Int_t bins[6];
  
  // optimized implementation
  for (Int_t binIdx = 0; binIdx < grid->GetNbins(); binIdx++)
  {
    Double_t value = grid->GetBinContent(binIdx, bins);
    Double_t error = grid->GetBinError(binIdx);
    
    if (histogram != 0)
    {
      if (var2 < 0)
      {
        value *= histogram->GetBinContent(bins[var1]);
        error *= histogram->GetBinContent(bins[var1]);
      }
      else
      {
        value *= histogram->GetBinContent(bins[var1], bins[var2]);
        error *= histogram->GetBinContent(bins[var1], bins[var2]);
      }
    }
    
    target->SetBinContent(bins, value);
    target->SetBinError(bins, error);
  }
}

//____________________________________________________________________
void AliUEHist::CorrectTracks(CFStep step1, CFStep step2, TH1* trackCorrection, Int_t var1, Int_t var2)
{
  // corrects from step1 to step2 by multiplying the tracks with trackCorrection
  // trackCorrection can be a function of eta (var1 == 0), pT (var1 == 1), leading pT (var1 == 2), multiplicity (var1 == 3), delta phi (var1 == 4)
  // if var2 >= 0 a two dimension correction is assumed in trackCorrection
  //
  // if trackCorrection is 0, just copies content from step1 to step2
  
  for (UInt_t region=0; region<fkRegions; region++)
    CorrectTracks(step1, step2, region, trackCorrection, var1, var2);
}

//____________________________________________________________________
void AliUEHist::CorrectTracks(CFStep step1, CFStep step2, Int_t region, TH1* trackCorrection, Int_t var1, Int_t var2)
{
  //
  // see documentation of CorrectTracks above
  //
  
  if (!fTrackHist[region])
    return;
   
  THnSparse* grid = fTrackHist[region]->GetGrid(step1)->GetGrid();
  THnSparse* target = fTrackHist[region]->GetGrid(step2)->GetGrid();
  
  Float_t entriesBefore = grid->GetEntries();
  
  MultiplyHistograms(grid, target, trackCorrection, var1, var2);
  
  Printf("AliUEHist::CorrectTracks: Corrected from %f (step %d) to %f (step %d) entries. Correction histogram: %f entries (integral: %f)", entriesBefore, step1, target->GetEntries(), step2, (trackCorrection) ? trackCorrection->GetEntries() : -1.0, (trackCorrection) ? trackCorrection->Integral() : -1.0); 
}

//____________________________________________________________________
void AliUEHist::CorrectEvents(CFStep step1, CFStep step2, TH1* eventCorrection, Int_t var1, Int_t var2)
{
  // corrects from step1 to step2 by multiplying the events with eventCorrection
  // eventCorrection is as function of leading pT (var == 0) or multiplicity (var == 1)
  //
  // if eventCorrection is 0, just copies content from step1 to step2
  
  AliCFGridSparse* grid = fEventHist->GetGrid(step1);
  AliCFGridSparse* target = fEventHist->GetGrid(step2);
  
  Float_t entriesBefore = grid->GetEntries();

  MultiplyHistograms(grid->GetGrid(), target->GetGrid(), eventCorrection, var1, var2);

  Printf("AliUEHist::CorrectEvents: Corrected from %f (step %d) to %f (step %d) entries. Correction histogram: %f entries (integral: %f)", entriesBefore, step1, target->GetEntries(), step2, (eventCorrection) ? eventCorrection->GetEntries() : -1.0, (eventCorrection) ? eventCorrection->Integral() : -1.0); 
}

//____________________________________________________________________
void AliUEHist::Correct(AliUEHist* corrections)
{
  // applies the given corrections to extract from the step kCFStepReconstructed all previous steps
  //
  // in this object the data is expected in the step kCFStepReconstructed
  
  if (fHistogramType.Length() == 0)
  {
    Printf("W-AliUEHist::Correct: fHistogramType not defined. Guessing histogram type...");
    if (fTrackHist[kToward]->GetNVar() < 5)
    {
      if (strcmp(fTrackHist[kToward]->GetTitle(), "d^{2}N_{ch}/d#varphid#eta") == 0)
        fHistogramType = "NumberDensitypT";
      else if (strcmp(fTrackHist[kToward]->GetTitle(), "d^{2}#Sigma p_{T}/d#varphid#eta") == 0)
        fHistogramType = "SumpT";
    }
    else if (fTrackHist[kToward]->GetNVar() == 5)
    {
      if (strcmp(fTrackHist[kToward]->GetGrid(0)->GetGrid()->GetAxis(3)->GetTitle(), "multiplicity") == 0)
        fHistogramType = "NumberDensityPhi";
      else if (strcmp(fTrackHist[kToward]->GetGrid(0)->GetGrid()->GetAxis(3)->GetTitle(), "centrality") == 0)
        fHistogramType = "NumberDensityPhiCentrality";
    }
      
    if (fHistogramType.Length() == 0)
      AliFatal("Cannot figure out histogram type. Try setting it manually...");
  }
  
  Printf("AliUEHist::Correct: Correcting %s...", fHistogramType.Data());
  
  if (strcmp(fHistogramType, "NumberDensitypT") == 0 || strcmp(fHistogramType, "NumberDensityPhi") == 0 || strcmp(fHistogramType, "SumpT") == 0)
  {
    // ---- track level
    
    // bias due to migration in leading pT (because the leading particle is not reconstructed, and the subleading is used)
    // extracted as function of leading pT
    Bool_t biasFromMC = kFALSE;
    const char* projAxis = "z";
    Int_t secondBin = -1;

    if (strcmp(fHistogramType, "NumberDensityPhi") == 0)
    {
      projAxis = "yz";
      secondBin = 4;
    }
    
    for (UInt_t region = 0; region < fkRegions; region++)
    {
      if (!fTrackHist[region])
        continue;
   
      TH1* leadingBiasTracks =  0;
      if (biasFromMC)
      {
        leadingBiasTracks = (TH1*) corrections->GetBias(kCFStepReconstructed, kCFStepTracked, region, projAxis, 0, -1, 1); // from MC
        Printf("WARNING: Using MC bias correction");
      }
      else
        leadingBiasTracks = (TH1*) GetBias(kCFStepBiasStudy, kCFStepReconstructed, region, projAxis, 0, -1, 1);          // from data
        
      CorrectTracks(kCFStepReconstructed, kCFStepTracked, region, leadingBiasTracks, 2, secondBin);
      if (region == kMin && fCombineMinMax)
      {
        CorrectTracks(kCFStepReconstructed, kCFStepTracked, kMax, leadingBiasTracks, 2, secondBin);
        delete leadingBiasTracks;
        break;
      }
      delete leadingBiasTracks;
    }
    
    TH1* leadingBiasEvents = 0;
    if (biasFromMC)
      leadingBiasEvents = (TH1*) corrections->GetBias(kCFStepReconstructed, kCFStepTracked, kToward, projAxis, 0, -1, 2); // from MC
    else
      leadingBiasEvents = (TH1*) GetBias(kCFStepBiasStudy, kCFStepReconstructed, kToward, projAxis, 0, -1, 2);          // from data
      
    //new TCanvas; leadingBiasEvents->DrawCopy();
    CorrectEvents(kCFStepReconstructed, kCFStepTracked, leadingBiasEvents, 0);
    delete leadingBiasEvents;
    
    // --- contamination correction ---
    
    TH2D* contamination = corrections->GetTrackingContamination();
    if (corrections->fContaminationEnhancement)
    {
      Printf("Applying contamination enhancement");
      
      for (Int_t x=1; x<=contamination->GetNbinsX(); x++)
        for (Int_t y=1; y<=contamination->GetNbinsX(); y++)
          contamination->SetBinContent(x, y, contamination->GetBinContent(x, y) * corrections->fContaminationEnhancement->GetBinContent(corrections->fContaminationEnhancement->GetXaxis()->FindBin(contamination->GetYaxis()->GetBinCenter(y))));
    }
    CorrectTracks(kCFStepTracked, kCFStepTrackedOnlyPrim, contamination, 0, 1);
    CorrectEvents(kCFStepTracked, kCFStepTrackedOnlyPrim, 0, 0);
    delete contamination;
    
    // --- efficiency correction ---
    // correct single-particle efficiency for associated particles
    // in addition correct for efficiency on trigger particles (tracks AND events)
    
    TH1* efficiencyCorrection = corrections->GetTrackingEfficiencyCorrection();
    // use kCFStepVertex as a temporary step (will be overwritten later anyway)
    CorrectTracks(kCFStepTrackedOnlyPrim, kCFStepVertex, efficiencyCorrection, 0, 1);
    delete efficiencyCorrection;
    
    // correct pT,T
    efficiencyCorrection = corrections->GetTrackEfficiency(kCFStepTrackedOnlyPrim, kCFStepAnaTopology, 1, -1, 2);
    CorrectEvents(kCFStepTrackedOnlyPrim, kCFStepAnaTopology, efficiencyCorrection, 0);
    CorrectTracks(kCFStepVertex, kCFStepAnaTopology, efficiencyCorrection, 2);
    delete efficiencyCorrection;
    
    // copy 
    CorrectTracks(kCFStepAnaTopology, kCFStepVertex, 0, -1);
    CorrectEvents(kCFStepAnaTopology, kCFStepVertex, 0, 0);
    
    // vertex correction on the level of events as function of multiplicity, weighting tracks and events with the same factor
    // practically independent of low pT cut 
    TH1D* vertexCorrection = (TH1D*) corrections->GetEventEfficiency(kCFStepVertex, kCFStepTriggered, 1);
    
    // convert stage from true multiplicity to observed multiplicity by simple conversion factor
    TH1D* vertexCorrectionObs = (TH1D*) vertexCorrection->Clone("vertexCorrection2");
    vertexCorrectionObs->Reset();
    
    TF1* func = new TF1("func", "[1]+[0]/(x-[2])");
    // some defaults
    func->SetParameters(0.1, 1, -0.7);
    vertexCorrection->Fit(func, "0I", "", 0, 3);
    for (Int_t i=1; i<=vertexCorrectionObs->GetNbinsX(); i++)
    {
      Float_t xPos = 1.0 / 0.77 * vertexCorrectionObs->GetXaxis()->GetBinCenter(i);
      if (xPos < 3)
        vertexCorrectionObs->SetBinContent(i, func->Eval(xPos));
      else
        vertexCorrectionObs->SetBinContent(i, vertexCorrection->Interpolate(xPos));
    }
  
    #if 0
    new TCanvas;
    vertexCorrection->DrawCopy();
    vertexCorrectionObs->SetLineColor(2);
    vertexCorrectionObs->DrawCopy("same");
    func->SetRange(0, 4);
    func->DrawClone("same");
    #endif
    
    CorrectTracks(kCFStepVertex, kCFStepTriggered, vertexCorrectionObs, 3);
    CorrectEvents(kCFStepVertex, kCFStepTriggered, vertexCorrectionObs, 1);
    delete vertexCorrectionObs;
    delete vertexCorrection;
    delete func;
    
    // copy 
    CorrectTracks(kCFStepTriggered, kCFStepAll, 0, -1);
    CorrectEvents(kCFStepTriggered, kCFStepAll, 0, 0);
  }
  else if (strcmp(fHistogramType, "NumberDensityPhiCentrality") == 0)
  {
    if (fTrackHist[0]->GetNVar() <= 5)
    {
      // do corrections copying between steps
//       CFStep step = kCFStepReconstructed;
      CFStep step = kCFStepBiasStudy;
      
      // copy 
      CorrectTracks(step, kCFStepTracked, 0, -1);
      CorrectEvents(step, kCFStepTracked, 0, -1);
      
      // Dont use eta in the following, because it is a Delta-eta axis
      
      // contamination correction
      // correct single-particle contamination for associated particles
      
      TH1* contamination = corrections->GetTrackingContamination(1);
      
      if (0)
      {
	Printf("Applying contamination enhancement");
	
	for (Int_t bin = 1; bin <= contamination->GetNbinsX(); bin++)
	{
	  printf("%f", contamination->GetBinContent(bin));
	  if (contamination->GetBinContent(bin) > 0)
	    contamination->SetBinContent(bin, 1.0 + 1.1 * (contamination->GetBinContent(bin) - 1.0));
	  printf(" --> %f\n", contamination->GetBinContent(bin));
	}
      }
	
      CorrectTracks(kCFStepTracked, kCFStepTrackedOnlyPrim, contamination, 1);
      delete contamination;    
      
      // correct for additional contamination due to trigger particle around phi ~ 0
      TH2* correlatedContamination = corrections->GetCorrelatedContamination();
      if (0)
      {
	Printf("Applying contamination enhancement");
	
	for (Int_t bin = 1; bin <= correlatedContamination->GetNbinsX(); bin++)
	  for (Int_t bin2 = 1; bin2 <= correlatedContamination->GetNbinsY(); bin2++)
	  {
	    printf("%f", correlatedContamination->GetBinContent(bin, bin2));
	    if (correlatedContamination->GetBinContent(bin, bin2) > 0)
	      correlatedContamination->SetBinContent(bin, bin2, 1.0 + 1.1 * (correlatedContamination->GetBinContent(bin, bin2) - 1.0));
	    printf(" --> %f\n", correlatedContamination->GetBinContent(bin, bin2));
	  }
      }
      
//       new TCanvas; correlatedContamination->DrawCopy("COLZ");
      CorrectCorrelatedContamination(kCFStepTrackedOnlyPrim, 0, correlatedContamination);
//       Printf("\n\n\nWARNING ---> SKIPPING CorrectCorrelatedContamination\n\n\n");
      
      delete correlatedContamination;
      
      // TODO correct for contamination of trigger particles (for tracks AND events)
      CorrectEvents(kCFStepTracked, kCFStepTrackedOnlyPrim, 0, 0);
      
      // --- efficiency correction ---
      // correct single-particle efficiency for associated particles
      // in addition correct for efficiency on trigger particles (tracks AND events)
      
      // in bins of pT and centrality
      TH1* efficiencyCorrection = corrections->GetTrackingEfficiencyCorrectionCentrality();
//       new TCanvas; efficiencyCorrection->DrawCopy("COLZ");
      // use kCFStepAnaTopology as a temporary step 
      CorrectTracks(kCFStepTrackedOnlyPrim, kCFStepAnaTopology, efficiencyCorrection, 1, 3);
      delete efficiencyCorrection;
      
      // correct pT,T in bins of pT and centrality
      efficiencyCorrection = corrections->GetTrackEfficiency(kCFStepTrackedOnlyPrim, kCFStepAnaTopology, 1, 3, 2);
      CorrectEvents(kCFStepTrackedOnlyPrim, kCFStepVertex, efficiencyCorrection, 0, 1);
      CorrectTracks(kCFStepAnaTopology, kCFStepVertex, efficiencyCorrection, 2, 3);
      delete efficiencyCorrection;
      
      // no correction for vertex finding efficiency and trigger efficiency needed in PbPb
      // copy 
      CorrectTracks(kCFStepVertex, kCFStepAll, 0, -1);
      CorrectEvents(kCFStepVertex, kCFStepAll, 0, -1);
    }
    else
    {
      // with 6 axes there is not enough memory, do the corrections in-place
      Printf(">>>>>>>> Applying corrections in place to reduce memory consumption");
      CFStep step = kCFStepBiasStudy;
//       CFStep step = kCFStepReconstructed;
     
      // Dont use eta in the following, because it is a Delta-eta axis
      
      // --- contamination correction ---
      // correct single-particle contamination for associated particles
      // correct contamination for trigger particles (tracks AND events)
      
      // in bins of p,T
      TH1* contamination = corrections->GetTrackingContamination(1);
      
      if (0)
      {
	Printf("Applying contamination enhancement");
	
	for (Int_t bin = 1; bin <= contamination->GetNbinsX(); bin++)
	{
	  printf("%f", contamination->GetBinContent(bin));
	  if (contamination->GetBinContent(bin) > 0)
	    contamination->SetBinContent(bin, 1.0 + 1.1 * (contamination->GetBinContent(bin) - 1.0));
	  printf(" --> %f\n", contamination->GetBinContent(bin));
	}
      }
	
      // correct pT,A in bins of pT
      CorrectTracks(step, step, contamination, 1);
      delete contamination;
      
      // correct pT,T in bins of pT (for tracks AND events)
      contamination = corrections->GetTrackEfficiency(kCFStepTracked, kCFStepTrackedOnlyPrim, 1, -1, 2);
      new TCanvas; contamination->DrawCopy();
      CorrectEvents(step, step, contamination, 0);
      CorrectTracks(step, step, contamination, 2);
      delete contamination;
      
      // correct for additional contamination due to trigger particle around phi ~ 0
      if (0)
      {
	TH2* correlatedContamination = corrections->GetCorrelatedContamination();
	if (1)
	{
	  Printf("Applying contamination enhancement");
	  
	  for (Int_t bin = 1; bin <= correlatedContamination->GetNbinsX(); bin++)
	    for (Int_t bin2 = 1; bin2 <= correlatedContamination->GetNbinsY(); bin2++)
	    {
	      printf("%f", correlatedContamination->GetBinContent(bin, bin2));
	      if (correlatedContamination->GetBinContent(bin, bin2) > 0)
		correlatedContamination->SetBinContent(bin, bin2, 1.0 + 1.1 * (correlatedContamination->GetBinContent(bin, bin2) - 1.0));
	      printf(" --> %f\n", correlatedContamination->GetBinContent(bin, bin2));
	    }
	}

	// new TCanvas; correlatedContamination->DrawCopy("COLZ");
	CorrectCorrelatedContamination(step, 0, correlatedContamination);

	delete correlatedContamination;
      }
      else
	Printf("\n\n\nWARNING ---> SKIPPING CorrectCorrelatedContamination\n\n\n");
      
      // --- tracking efficiency correction ---
      // correct single-particle efficiency for associated particles
      // correct for efficiency on trigger particles (tracks AND events)
      
      // in bins of pT and centrality
      TH1* efficiencyCorrection = corrections->GetTrackingEfficiencyCorrectionCentrality();
      // new TCanvas; efficiencyCorrection->DrawCopy("COLZ");

      // correct pT,A in bins of pT and centrality
      CorrectTracks(step, step, efficiencyCorrection, 1, 3);
      delete efficiencyCorrection;
      
      // correct pT,T in bins of pT and centrality
      efficiencyCorrection = corrections->GetTrackEfficiency(kCFStepTrackedOnlyPrim, kCFStepAnaTopology, 1, 3, 2);
      CorrectEvents(step, step, efficiencyCorrection, 0, 1);
      CorrectTracks(step, step, efficiencyCorrection, 2, 3);
      
      delete efficiencyCorrection;
    }
  }
  else
    AliFatal(Form("Unknown histogram for correction: %s", GetTitle()));
}

//____________________________________________________________________
THnBase* AliUEHist::GetTrackEfficiencyND(CFStep step1, CFStep step2)
{
  // creates a track-level efficiency by dividing step2 by step1
  // in all dimensions but the particle species one
  
  AliCFContainer* sourceContainer = fTrackHistEfficiency;
  // step offset because we start with kCFStepAnaTopology
  step1 = (CFStep) ((Int_t) step1 - (Int_t) kCFStepAnaTopology);
  step2 = (CFStep) ((Int_t) step2 - (Int_t) kCFStepAnaTopology);
  
  ResetBinLimits(sourceContainer->GetGrid(step1));
  ResetBinLimits(sourceContainer->GetGrid(step2));

  if (fEtaMax > fEtaMin)
  {
    Printf("Restricted eta-range to %f %f", fEtaMin, fEtaMax);
    sourceContainer->GetGrid(step1)->SetRangeUser(0, fEtaMin, fEtaMax);
    sourceContainer->GetGrid(step2)->SetRangeUser(0, fEtaMin, fEtaMax);
  }
  
  Int_t dimensions[] = { 0, 1, 3, 4 };
  THnBase* generated = sourceContainer->GetGrid(step1)->GetGrid()->ProjectionND(4, dimensions);
  THnBase* measured = sourceContainer->GetGrid(step2)->GetGrid()->ProjectionND(4, dimensions);
  
//   Printf("%d %d %f %f", step1, step2, generated->GetEntries(), measured->GetEntries());
  
  ResetBinLimits(sourceContainer->GetGrid(step1));
  ResetBinLimits(sourceContainer->GetGrid(step2));

  measured->Divide(measured, generated, 1, 1, "B");
  
  delete generated;
  
  return measured;
}

//____________________________________________________________________
TH1* AliUEHist::GetTrackEfficiency(CFStep step1, CFStep step2, Int_t axis1, Int_t axis2, Int_t source, Int_t axis3)
{
  // creates a track-level efficiency by dividing step2 by step1
  // projected to axis1 and axis2 (optional if >= 0)
  //
  // source: 0 = fTrackHist; 1 = fTrackHistEfficiency; 2 = fTrackHistEfficiency rebinned for pT,T / pT,lead binning
  
  // integrate over regions
  // cache it for efficiency (usually more than one efficiency is requested)
  
  AliCFContainer* sourceContainer = 0;
  
  if (source == 0)
  {
    if (!fCache)
    {
      fCache = (AliCFContainer*) fTrackHist[0]->Clone();
      for (UInt_t i = 1; i < fkRegions; i++)
        if (fTrackHist[i])
          fCache->Add(fTrackHist[i]);
    }
    sourceContainer = fCache;
  }
  else if (source == 1 || source == 2)
  {
    sourceContainer = fTrackHistEfficiency;
    // step offset because we start with kCFStepAnaTopology
    step1 = (CFStep) ((Int_t) step1 - (Int_t) kCFStepAnaTopology);
    step2 = (CFStep) ((Int_t) step2 - (Int_t) kCFStepAnaTopology);
  }
  else
    return 0;
        
  // reset all limits and set the right ones except those in axis1, axis2 and axis3
  ResetBinLimits(sourceContainer->GetGrid(step1));
  ResetBinLimits(sourceContainer->GetGrid(step2));
  if (fEtaMax > fEtaMin && axis1 != 0 && axis2 != 0 && axis3 != 0)
  {
    Printf("Restricted eta-range to %f %f", fEtaMin, fEtaMax);
    sourceContainer->GetGrid(step1)->SetRangeUser(0, fEtaMin, fEtaMax);
    sourceContainer->GetGrid(step2)->SetRangeUser(0, fEtaMin, fEtaMax);
  }
  if (fPtMax > fPtMin && axis1 != 1 && axis2 != 1 && axis3 != 1)
  {
    Printf("Restricted pt-range to %f %f", fPtMin, fPtMax);
    sourceContainer->GetGrid(step1)->SetRangeUser(1, fPtMin, fPtMax);
    sourceContainer->GetGrid(step2)->SetRangeUser(1, fPtMin, fPtMax);
  }
  if (fPartSpecies != -1 && axis1 != 2 && axis2 != 2 && axis3 != 2)
  {
    Printf("Restricted to particle species %d", fPartSpecies);
    sourceContainer->GetGrid(step1)->SetRangeUser(2, fPartSpecies, fPartSpecies);
    sourceContainer->GetGrid(step2)->SetRangeUser(2, fPartSpecies, fPartSpecies);
  }
  if (fCentralityMax > fCentralityMin && axis1 != 3 && axis2 != 3 && axis3 != 3)
  {
    Printf("Restricted centrality range to %f %f", fCentralityMin, fCentralityMax);
    sourceContainer->GetGrid(step1)->SetRangeUser(3, fCentralityMin, fCentralityMax);
    sourceContainer->GetGrid(step2)->SetRangeUser(3, fCentralityMin, fCentralityMax);
  }
  if (fZVtxMax > fZVtxMin && axis1 != 4 && axis2 != 4 && axis3 != 4)
  {
    Printf("Restricted z-vtx range to %f %f", fZVtxMin, fZVtxMax);
    sourceContainer->GetGrid(step1)->SetRangeUser(4, fZVtxMin, fZVtxMax);
    sourceContainer->GetGrid(step2)->SetRangeUser(4, fZVtxMin, fZVtxMax);
  }
  
  TH1* measured = 0;
  TH1* generated = 0;
    
  if (axis3 >= 0)
  {
    generated = sourceContainer->Project(step1, axis1, axis2, axis3);
    measured = sourceContainer->Project(step2, axis1, axis2, axis3);
  }
  else if (axis2 >= 0)
  {
    generated = sourceContainer->Project(step1, axis1, axis2);
    measured = sourceContainer->Project(step2, axis1, axis2);
  }
  else
  {
    generated = sourceContainer->Project(step1, axis1);
    measured = sourceContainer->Project(step2, axis1);
  }
  
  // check for bins with less than 50 entries, print warning
  Int_t binBegin[3];
  Int_t binEnd[3];
  
  binBegin[0] = 1;
  binBegin[1] = 1;
  binBegin[2] = 1;
  
  binEnd[0] = generated->GetNbinsX();
  binEnd[1] = generated->GetNbinsY();
  binEnd[2] = generated->GetNbinsZ();
  
  if (fEtaMax > fEtaMin)
  {
    if (axis1 == 0)
    {
      binBegin[0] = generated->GetXaxis()->FindBin(fEtaMin);
      binEnd[0]   = generated->GetXaxis()->FindBin(fEtaMax);
    }
    if (axis2 == 0)
    {
      binBegin[1] = generated->GetYaxis()->FindBin(fEtaMin);
      binEnd[1]   = generated->GetYaxis()->FindBin(fEtaMax);
    }
    if (axis3 == 0)
    {
      binBegin[2] = generated->GetZaxis()->FindBin(fEtaMin);
      binEnd[2]   = generated->GetZaxis()->FindBin(fEtaMax);
    }
  }
  
  if (fPtMax > fPtMin)
  {
    // TODO this is just checking up to 15 for now
    Float_t ptMax = TMath::Min((Float_t) 15., fPtMax);
    if (axis1 == 1)
    {
      binBegin[0] = generated->GetXaxis()->FindBin(fPtMin);
      binEnd[0]   = generated->GetXaxis()->FindBin(ptMax);
    }
    if (axis2 == 1)
    {
      binBegin[1] = generated->GetYaxis()->FindBin(fPtMin);
      binEnd[1]   = generated->GetYaxis()->FindBin(ptMax);
    }
    if (axis3 == 1)
    {
      binBegin[2] = generated->GetZaxis()->FindBin(fPtMin);
      binEnd[2]   = generated->GetZaxis()->FindBin(ptMax);
    }
  }
  
  Int_t total = 0;
  Int_t count = 0;
  Int_t vars[3];
  
  for (Int_t i=0; i<3; i++)
    vars[i] = binBegin[i];
    
  const Int_t limit = 50;
  while (1)
  {
    if (generated->GetDimension() == 1 && generated->GetBinContent(vars[0]) < limit)
    {
      Printf("Empty bin at %s=%.2f (%.2f entries)", generated->GetXaxis()->GetTitle(), generated->GetXaxis()->GetBinCenter(vars[0]), generated->GetBinContent(vars[0]));
      count++;
    } 
    else if (generated->GetDimension() == 2 && generated->GetBinContent(vars[0], vars[1]) < limit)
    {
      Printf("Empty bin at %s=%.2f %s=%.2f (%.2f entries)", 
        generated->GetXaxis()->GetTitle(), generated->GetXaxis()->GetBinCenter(vars[0]),
        generated->GetYaxis()->GetTitle(), generated->GetYaxis()->GetBinCenter(vars[1]),
        generated->GetBinContent(vars[0], vars[1]));
      count++;
    }
    else if (generated->GetDimension() == 3 && generated->GetBinContent(vars[0], vars[1], vars[2]) < limit)
    {
      Printf("Empty bin at %s=%.2f %s=%.2f %s=%.2f (%.2f entries)", 
        generated->GetXaxis()->GetTitle(), generated->GetXaxis()->GetBinCenter(vars[0]),
        generated->GetYaxis()->GetTitle(), generated->GetYaxis()->GetBinCenter(vars[1]),
        generated->GetZaxis()->GetTitle(), generated->GetZaxis()->GetBinCenter(vars[2]),
        generated->GetBinContent(vars[0], vars[1], vars[2]));
      count++;
    }
    
    vars[2]++;
    if (vars[2] == binEnd[2]+1)
    {
      vars[2] = binBegin[2];
      vars[1]++;
    }
    
    if (vars[1] == binEnd[1]+1)
    {
      vars[1] = binBegin[1];
      vars[0]++;
    }
    
    if (vars[0] == binEnd[0]+1)
      break;
    total++;
  }

  Printf("Correction has %d empty bins (out of %d bins)", count, total);
  
  // rebin if required
  if (source == 2)
  {
    TAxis* axis = fEventHist->GetGrid(0)->GetGrid()->GetAxis(0);
    
    if (axis->GetNbins() < measured->GetNbinsX())
    {
      if (axis2 != -1)
      {
        // 2d rebin with variable axis does not exist in root
        
        TH1* tmp = measured;
        measured = new TH2D(Form("%s_rebinned", tmp->GetName()), tmp->GetTitle(), axis->GetNbins(), axis->GetXbins()->GetArray(), tmp->GetNbinsY(), tmp->GetYaxis()->GetXbins()->GetArray());
        for (Int_t x=1; x<=tmp->GetNbinsX(); x++)
          for (Int_t y=1; y<=tmp->GetNbinsY(); y++)
          {
            ((TH2*) measured)->Fill(tmp->GetXaxis()->GetBinCenter(x), tmp->GetYaxis()->GetBinCenter(y), tmp->GetBinContent(x, y));
            measured->SetBinError(x, y, 0); // cannot trust bin error, set to 0
          }
        delete tmp;
        
        tmp = generated;
        generated = new TH2D(Form("%s_rebinned", tmp->GetName()), tmp->GetTitle(), axis->GetNbins(), axis->GetXbins()->GetArray(), tmp->GetNbinsY(), tmp->GetYaxis()->GetXbins()->GetArray());
        for (Int_t x=1; x<=tmp->GetNbinsX(); x++)
          for (Int_t y=1; y<=tmp->GetNbinsY(); y++)
          {
            ((TH2*) generated)->Fill(tmp->GetXaxis()->GetBinCenter(x), tmp->GetYaxis()->GetBinCenter(y), tmp->GetBinContent(x, y));
            generated->SetBinError(x, y, 0); // cannot trust bin error, set to 0
          }
        delete tmp;
      }
      else
      {
        TH1* tmp = measured;
        measured = tmp->Rebin(axis->GetNbins(), Form("%s_rebinned", tmp->GetName()), axis->GetXbins()->GetArray());
        delete tmp;
        
        tmp = generated;
        generated = tmp->Rebin(axis->GetNbins(), Form("%s_rebinned", tmp->GetName()), axis->GetXbins()->GetArray());
        delete tmp;
      }
    }
    else if (axis->GetNbins() > measured->GetNbinsX())
    {
      if (axis2 != -1)
        AliFatal("Rebinning only works for 1d at present");
  
      // this is an unfortunate case where the number of bins has to be increased in principle
      // there is a region where the binning is finner in one histogram and a region where it is the other way round
      // this cannot be resolved in principle, but as we only calculate the ratio the bin in the second region get the same entries
      // only a certain binning is supported here
      if (axis->GetNbins() != 100 || measured->GetNbinsX() != 39)
        AliFatal(Form("Invalid binning --> %d %d", axis->GetNbins(), measured->GetNbinsX()));
      
      Double_t newBins[] = {0.0, 0.5, 1.0, 1.5, 2.0, 2.5, 3.0, 3.5, 4.0, 4.5, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 12.0, 14.0, 16.0, 18.0, 20.0, 25.0, 30.0, 35.0, 40.0, 45.0, 50.0, 100.0};
      
      // reduce binning below 5 GeV/c
      TH1* tmp = measured;
      measured = tmp->Rebin(27, Form("%s_rebinned", tmp->GetName()), newBins);
      delete tmp;
      
      // increase binning above 5 GeV/c
      tmp = measured;
      measured = new TH1F(Form("%s_rebinned2", tmp->GetName()), tmp->GetTitle(), axis->GetNbins(), axis->GetBinLowEdge(1), axis->GetBinUpEdge(axis->GetNbins()));
      for (Int_t bin=1; bin<=measured->GetNbinsX(); bin++)
      {
        measured->SetBinContent(bin, tmp->GetBinContent(tmp->FindBin(measured->GetBinCenter(bin))));
        measured->SetBinError(bin, tmp->GetBinError(tmp->FindBin(measured->GetBinCenter(bin))));
      }
      delete tmp;
      
      // reduce binning below 5 GeV/c
      tmp = generated;
      generated = tmp->Rebin(27, Form("%s_rebinned", tmp->GetName()), newBins);
      delete tmp;
      
      // increase binning above 5 GeV/c
      tmp = generated;
      generated = new TH1F(Form("%s_rebinned2", tmp->GetName()), tmp->GetTitle(), axis->GetNbins(), axis->GetBinLowEdge(1), axis->GetBinUpEdge(axis->GetNbins()));
      for (Int_t bin=1; bin<=generated->GetNbinsX(); bin++)
      {
        generated->SetBinContent(bin, tmp->GetBinContent(tmp->FindBin(generated->GetBinCenter(bin))));
        generated->SetBinError(bin, tmp->GetBinError(tmp->FindBin(generated->GetBinCenter(bin))));
      }
      delete tmp;
    }
  }
  
  measured->Divide(measured, generated, 1, 1, "B");
  
  delete generated;
  
  ResetBinLimits(sourceContainer->GetGrid(step1));
  ResetBinLimits(sourceContainer->GetGrid(step2));
  
  return measured;
}

//____________________________________________________________________
TH1* AliUEHist::GetEventEfficiency(CFStep step1, CFStep step2, Int_t axis1, Int_t axis2, Float_t ptLeadMin, Float_t ptLeadMax)
{
  // creates a event-level efficiency by dividing step2 by step1
  // projected to axis1 and axis2 (optional if >= 0)
  
  if (ptLeadMax > ptLeadMin)
  {
    fEventHist->GetGrid(step1)->SetRangeUser(0, ptLeadMin, ptLeadMax);
    fEventHist->GetGrid(step2)->SetRangeUser(0, ptLeadMin, ptLeadMax);
  }
  
  TH1* measured = 0;
  TH1* generated = 0;
    
  if (axis2 >= 0)
  {
    generated = fEventHist->Project(step1, axis1, axis2);
    measured = fEventHist->Project(step2, axis1, axis2);
  }
  else
  {
    generated = fEventHist->Project(step1, axis1);
    measured = fEventHist->Project(step2, axis1);
  }
  
  measured->Divide(measured, generated, 1, 1, "B");
  
  delete generated;
  
  if (ptLeadMax > ptLeadMin)
  {
    fEventHist->GetGrid(step1)->SetRangeUser(0, 0, -1);
    fEventHist->GetGrid(step2)->SetRangeUser(0, 0, -1);
  }
  
  return measured;
}

//____________________________________________________________________
void AliUEHist::WeightHistogram(TH3* hist1, TH1* hist2)
{
  // weights each entry of the 3d histogram hist1 with the 1d histogram hist2 
  // where the matching is done of the z axis of hist1 with the x axis of hist2
  
  if (hist1->GetNbinsZ() != hist2->GetNbinsX())
    AliFatal(Form("Inconsistent binning %d %d", hist1->GetNbinsZ(), hist2->GetNbinsX()));
  
  for (Int_t x=1; x<=hist1->GetNbinsX(); x++)
  {
    for (Int_t y=1; y<=hist1->GetNbinsY(); y++)
    {
      for (Int_t z=1; z<=hist1->GetNbinsZ(); z++)
      {
        if (hist2->GetBinContent(z) > 0)
        {
          hist1->SetBinContent(x, y, z, hist1->GetBinContent(x, y, z) / hist2->GetBinContent(z));
          hist1->SetBinError(x, y, z, hist1->GetBinError(x, y, z) / hist2->GetBinContent(z));
        }
        else
        {
          hist1->SetBinContent(x, y, z, 0);
          hist1->SetBinError(x, y, z, 0);
        }
      }
    }
  }
}  

//____________________________________________________________________
TH1* AliUEHist::GetBias(CFStep step1, CFStep step2, Int_t region, const char* axis, Float_t leadPtMin, Float_t leadPtMax, Int_t weighting)
{
  // extracts the track-level bias (integrating out the multiplicity) between two steps (dividing step2 by step1)
  // in the given region (sum over all regions is calculated if region == -1)
  // done by weighting the track-level distribution with the number of events as function of leading pT
  // and then calculating the ratio between the distributions
  // projected to axis which is a TH3::Project3D string, e.g. "x", or "yx"
  //   no projection is done if axis == 0
  // weighting: 0 = tracks weighted with events (as discussed above)
  //            1 = only track bias is returned
  //            2 = only event bias is returned
  
  AliCFContainer* tmp = 0;
  
  if (region == -1)
  {
    tmp = (AliCFContainer*) fTrackHist[0]->Clone();
    for (UInt_t i = 1; i < fkRegions; i++)
      if (fTrackHist[i])
	tmp->Add(fTrackHist[i]);
  }
  else if (region == kMin && fCombineMinMax)
  {
    tmp = (AliCFContainer*) fTrackHist[kMin]->Clone();
    tmp->Add(fTrackHist[kMax]);
  }
  else
    tmp = fTrackHist[region];
  
  ResetBinLimits(tmp->GetGrid(step1));
  ResetBinLimits(fEventHist->GetGrid(step1));
  SetBinLimits(tmp->GetGrid(step1));
  
  ResetBinLimits(tmp->GetGrid(step2));
  ResetBinLimits(fEventHist->GetGrid(step2));
  SetBinLimits(tmp->GetGrid(step2));
  
  TH1D* events1 = (TH1D*)fEventHist->Project(step1, 0);
  TH3D* hist1 = (TH3D*)tmp->Project(step1, 0, tmp->GetNVar()-1, 2);
  if (weighting == 0)
    WeightHistogram(hist1, events1);
  
  TH1D* events2 = (TH1D*)fEventHist->Project(step2, 0);
  TH3D* hist2 = (TH3D*)tmp->Project(step2, 0, tmp->GetNVar()-1, 2);
  if (weighting == 0)
    WeightHistogram(hist2, events2);
  
  TH1* generated = hist1;
  TH1* measured = hist2;
  
  if (weighting == 0 || weighting == 1)
  {
    if (axis)
    {
      if (leadPtMax > leadPtMin)
      {
        hist1->GetZaxis()->SetRangeUser(leadPtMin, leadPtMax);
        hist2->GetZaxis()->SetRangeUser(leadPtMin, leadPtMax);
      }
      
      if (fEtaMax > fEtaMin && !TString(axis).Contains("x"))
      {
        hist1->GetXaxis()->SetRangeUser(fEtaMin, fEtaMax);
        hist2->GetXaxis()->SetRangeUser(fEtaMin, fEtaMax);
      }
    
      generated = hist1->Project3D(axis);
      measured  = hist2->Project3D(axis);
      
      // delete hists here if projection has been done
      delete hist1;
      delete hist2;
    }
    delete events1;
    delete events2;
  }
  else if (weighting == 2)
  {
    delete hist1;
    delete hist2;
    generated = events1;
    measured = events2;
  }
  
  measured->Divide(generated);
  
  delete generated;
  
  ResetBinLimits(tmp->GetGrid(step1));
  ResetBinLimits(tmp->GetGrid(step2));
  
  if ((region == -1) || (region == kMin && fCombineMinMax))
    delete tmp;
  
  return measured;
}

//____________________________________________________________________
void AliUEHist::CorrectCorrelatedContamination(CFStep step, Int_t region, TH1* trackCorrection)
{
  // corrects for the given factor in a small delta-eta and delta-phi window as function of pT,A and pT,T
  
  if (!fTrackHist[region])
    return;
   
  THnSparse* grid = fTrackHist[region]->GetGrid(step)->GetGrid();
  
  Int_t var1 = 1;
  Int_t var2 = 2;
  
  if (grid->GetAxis(var1)->GetNbins() != trackCorrection->GetNbinsX())
    AliFatal(Form("Invalid binning (var1): %d %d", grid->GetAxis(var1)->GetNbins(), trackCorrection->GetNbinsX()));
    
  if (grid->GetAxis(var2)->GetNbins() != trackCorrection->GetNbinsY())
    AliFatal(Form("Invalid binning (var2): %d %d", grid->GetAxis(var2)->GetNbins(), trackCorrection->GetNbinsY()));
  
  // optimized implementation
  for (Int_t binIdx = 0; binIdx < grid->GetNbins(); binIdx++)
  {
    Int_t bins[6];
    
    Double_t value = grid->GetBinContent(binIdx, bins);
    Double_t error = grid->GetBinError(binIdx);
    
    // check eta and phi axes
    if (TMath::Abs(grid->GetAxis(0)->GetBinCenter(bins[0])) > 0.1)
      continue;
    if (TMath::Abs(grid->GetAxis(4)->GetBinCenter(bins[4])) > 0.1)
      continue;
    
    value *= trackCorrection->GetBinContent(bins[var1], bins[var2]);
    error *= trackCorrection->GetBinContent(bins[var1], bins[var2]);
    
    grid->SetBinContent(bins, value);
    grid->SetBinError(bins, error);
  }
 
  Printf("AliUEHist::CorrectCorrelatedContamination: Corrected.");
}

//____________________________________________________________________
TH2* AliUEHist::GetCorrelatedContamination()
{
  // contamination correlated with the trigger particle is evaluated between step kCFStepTracked and kCFStepTrackedOnlyPrim in the region of delta eta and delta phi < 0.1 (smallest bin!)
  
  Int_t step1 = kCFStepTrackedOnlyPrim;
  Int_t step2 = kCFStepTracked;
  
  fTrackHist[0]->GetGrid(step1)->SetRangeUser(0, -0.01, 0.01); // delta eta
  fTrackHist[0]->GetGrid(step1)->SetRangeUser(4, -0.01, 0.01); // delta phi
  TH2* tracksStep1 = (TH2*) fTrackHist[0]->Project(step1, 1, 2);
  
  fTrackHist[0]->GetGrid(step2)->SetRangeUser(0, -0.01, 0.01); // delta eta
  fTrackHist[0]->GetGrid(step2)->SetRangeUser(4, -0.01, 0.01); // delta phi
  TH2* tracksStep2 = (TH2*) fTrackHist[0]->Project(step2, 1, 2);
  
  tracksStep1->Divide(tracksStep2);
  
  TH1* triggersStep1 = fEventHist->Project(step1, 0);
  TH1* triggersStep2 = fEventHist->Project(step2, 0);
  
  TH1* singleParticle = GetTrackingContamination(1);
  
  for (Int_t x=1; x<=tracksStep1->GetNbinsX(); x++)
    for (Int_t y=1; y<=tracksStep1->GetNbinsY(); y++)
      if (singleParticle->GetBinContent(x) > 0 && triggersStep1->GetBinContent(y) > 0)
        tracksStep1->SetBinContent(x, y, tracksStep1->GetBinContent(x, y) / triggersStep1->GetBinContent(y) * triggersStep2->GetBinContent(y) / singleParticle->GetBinContent(x));
      else
        tracksStep1->SetBinContent(x, y, 0);
        
  delete singleParticle;
  delete tracksStep2;
  delete triggersStep1;
  delete triggersStep2;
        
  return tracksStep1;
}

//____________________________________________________________________
TH2D* AliUEHist::GetTrackingEfficiency()
{
  // extracts the tracking efficiency by calculating the efficiency from step kCFStepAnaTopology to kCFStepTrackedOnlyPrim
  // integrates over the regions and all other variables than pT and eta to increase the statistics
  //
  // returned histogram has to be deleted by the user

  return dynamic_cast<TH2D*> (GetTrackEfficiency(kCFStepAnaTopology, kCFStepTrackedOnlyPrim, 0, 1));
}
  
//____________________________________________________________________
TH2D* AliUEHist::GetFakeRate()
{
  return dynamic_cast<TH2D*> (GetTrackEfficiency(kCFStepTracked, (CFStep) (kCFStepTracked+3), 0, 1));
}

//____________________________________________________________________
TH2D* AliUEHist::GetTrackingEfficiencyCentrality()
{
  // extracts the tracking efficiency by calculating the efficiency from step kCFStepAnaTopology to kCFStepTrackedOnlyPrim
  // integrates over the regions and all other variables than pT, centrality to increase the statistics
  //
  // returned histogram has to be deleted by the user

  return dynamic_cast<TH2D*> (GetTrackEfficiency(kCFStepAnaTopology, kCFStepTrackedOnlyPrim, 1, 3));
}

//____________________________________________________________________
TH1D* AliUEHist::GetTrackingEfficiency(Int_t axis)
{
  // extracts the tracking efficiency by calculating the efficiency from step kCFStepAnaTopology to kCFStepTrackedOnlyPrim
  // integrates over the regions and all other variables than pT (axis == 0) and eta (axis == 1) to increase the statistics

  return dynamic_cast<TH1D*> (GetTrackEfficiency(kCFStepAnaTopology, kCFStepTrackedOnlyPrim, axis));
}

//____________________________________________________________________
TH1D* AliUEHist::GetFakeRate(Int_t axis)
{
  return dynamic_cast<TH1D*> (GetTrackEfficiency(kCFStepTracked, (CFStep) (kCFStepTracked+3), axis));
}
//____________________________________________________________________
TH2D* AliUEHist::GetTrackingCorrection()
{
  // extracts the tracking correction by calculating the efficiency from step kCFStepAnaTopology to kCFStepTracked
  // integrates over the regions and all other variables than pT and eta to increase the statistics
  //
  // returned histogram has to be deleted by the user

  return dynamic_cast<TH2D*> (GetTrackEfficiency(kCFStepTracked, kCFStepAnaTopology, 0, 1));
}
  
//____________________________________________________________________
TH1D* AliUEHist::GetTrackingCorrection(Int_t axis)
{
  // extracts the tracking correction by calculating the efficiency from step kCFStepAnaTopology to kCFStepTracked
  // integrates over the regions and all other variables than pT (axis == 0) and eta (axis == 1) to increase the statistics

  return dynamic_cast<TH1D*> (GetTrackEfficiency(kCFStepTracked, kCFStepAnaTopology, axis));
}

//____________________________________________________________________
TH2D* AliUEHist::GetTrackingEfficiencyCorrection()
{
  // extracts the tracking correction by calculating the efficiency from step kCFStepAnaTopology to kCFStepTracked
  // integrates over the regions and all other variables than pT and eta to increase the statistics
  //
  // returned histogram has to be deleted by the user

  return dynamic_cast<TH2D*> (GetTrackEfficiency(kCFStepTrackedOnlyPrim, kCFStepAnaTopology, 0, 1));
}
  
//____________________________________________________________________
TH2D* AliUEHist::GetTrackingEfficiencyCorrectionCentrality()
{
  // extracts the tracking correction by calculating the efficiency from step kCFStepAnaTopology to kCFStepTracked
  // integrates over the regions and all other variables than pT and centrality to increase the statistics
  //
  // returned histogram has to be deleted by the user

  return dynamic_cast<TH2D*> (GetTrackEfficiency(kCFStepTrackedOnlyPrim, kCFStepAnaTopology, 1, 3));
}
  
//____________________________________________________________________
TH1D* AliUEHist::GetTrackingEfficiencyCorrection(Int_t axis)
{
  // extracts the tracking correction by calculating the efficiency from step kCFStepAnaTopology to kCFStepTracked
  // integrates over the regions and all other variables than pT (axis == 0) and eta (axis == 1) to increase the statistics

  return dynamic_cast<TH1D*> (GetTrackEfficiency(kCFStepTrackedOnlyPrim, kCFStepAnaTopology, axis));
}

//____________________________________________________________________
TH2D* AliUEHist::GetTrackingContamination()
{
  // extracts the tracking contamination by secondaries by calculating the efficiency from step kCFStepTrackedOnlyPrim to kCFStepTracked
  // integrates over the regions and all other variables than pT and eta to increase the statistics
  //
  // returned histogram has to be deleted by the user

  return dynamic_cast<TH2D*> (GetTrackEfficiency(kCFStepTracked, kCFStepTrackedOnlyPrim, 0, 1));
}
  
//____________________________________________________________________
TH2D* AliUEHist::GetTrackingContaminationCentrality()
{
  // extracts the tracking contamination by secondaries by calculating the efficiency from step kCFStepTrackedOnlyPrim to kCFStepTracked
  // integrates over the regions and all other variables than pT and centrality to increase the statistics
  //
  // returned histogram has to be deleted by the user

  return dynamic_cast<TH2D*> (GetTrackEfficiency(kCFStepTracked, kCFStepTrackedOnlyPrim, 1, 3));
}
  
//____________________________________________________________________
TH1D* AliUEHist::GetTrackingContamination(Int_t axis)
{
  // extracts the tracking contamination by secondaries by calculating the efficiency from step kCFStepTrackedOnlyPrim to kCFStepTracked
  // integrates over the regions and all other variables than pT (axis == 0) and eta (axis == 1) to increase the statistics

  return dynamic_cast<TH1D*> (GetTrackEfficiency(kCFStepTracked, kCFStepTrackedOnlyPrim, axis));
}

//____________________________________________________________________
const char* AliUEHist::GetRegionTitle(Region region)
{
  // returns the name of the given region
  
  switch (region)
  {
    case kToward:
      return "Towards";
    case kAway:
      return "Away";
    case kMin:
      return (fCombineMinMax) ? "Transverse" : "Min";
    case kMax:
      return "Max";
  }
  
  return 0;
}
  
//____________________________________________________________________
const char* AliUEHist::GetStepTitle(CFStep step)
{
  // returns the name of the given step
  
  switch (step)
  {
    case kCFStepAll:
      return "All events";
    case kCFStepTriggered:
      return "Triggered";
    case kCFStepVertex:
      return "Primary Vertex";
    case kCFStepAnaTopology:
      return "Required analysis topology";
    case kCFStepTrackedOnlyPrim:
      return "Tracked (matched MC, only primaries)";
    case kCFStepTracked:
      return "Tracked (matched MC, all)";
    case kCFStepReconstructed:
      return "Reconstructed";
    case kCFStepRealLeading:
      return "Correct leading particle identified";
    case kCFStepBiasStudy:
      return "Bias study applying tracking efficiency";
    case kCFStepBiasStudy2:
      return "Bias study applying tracking efficiency in two steps";
    case kCFStepCorrected:
      return "Corrected for efficiency on-the-fly";
  }
  
  return 0;
}

//____________________________________________________________________
void AliUEHist::CopyReconstructedData(AliUEHist* from)
{
  // copies those histograms extracted from ESD to this object
  
  // TODO at present only the pointers are copied
  
  for (Int_t region=0; region<4; region++)
  {
    if (!fTrackHist[region])
      continue;
  
    fTrackHist[region]->SetGrid(AliUEHist::kCFStepReconstructed, from->fTrackHist[region]->GetGrid(AliUEHist::kCFStepReconstructed));
    //fTrackHist[region]->SetGrid(AliUEHist::kCFStepTrackedOnlyPrim, from->fTrackHist[region]->GetGrid(AliUEHist::kCFStepTrackedOnlyPrim));
    fTrackHist[region]->SetGrid(AliUEHist::kCFStepBiasStudy,     from->fTrackHist[region]->GetGrid(AliUEHist::kCFStepBiasStudy));
  }
    
  fEventHist->SetGrid(AliUEHist::kCFStepReconstructed, from->fEventHist->GetGrid(AliUEHist::kCFStepReconstructed));
  //fEventHist->SetGrid(AliUEHist::kCFStepTrackedOnlyPrim, from->fEventHist->GetGrid(AliUEHist::kCFStepTrackedOnlyPrim));
  fEventHist->SetGrid(AliUEHist::kCFStepBiasStudy,     from->fEventHist->GetGrid(AliUEHist::kCFStepBiasStudy));
}

void AliUEHist::DeepCopy(AliUEHist* from)
{
  // copies the entries of this object's members from the object <from> to this object
  // fills using the fill function and thus allows that the objects have different binning

  for (Int_t region=0; region<4; region++)
  {
    if (!fTrackHist[region] || !from->fTrackHist[region])
      continue;
  
    for (Int_t step=0; step<fTrackHist[region]->GetNStep(); step++)
    {
      Printf("Copying region %d step %d", region, step);
      THnSparse* target = fTrackHist[region]->GetGrid(step)->GetGrid();
      THnSparse* source = from->fTrackHist[region]->GetGrid(step)->GetGrid();
      
      target->Reset();
      target->RebinnedAdd(source);
    }
  }
  
  for (Int_t step=0; step<fEventHist->GetNStep(); step++)
  {
    Printf("Ev: Copying step %d", step);
    THnSparse* target = fEventHist->GetGrid(step)->GetGrid();
    THnSparse* source = from->fEventHist->GetGrid(step)->GetGrid();

    target->Reset();
    target->RebinnedAdd(source);
  }
  
  for (Int_t step=0; step<TMath::Min(fTrackHistEfficiency->GetNStep(), from->fTrackHistEfficiency->GetNStep()); step++)
  {
    if (!from->fTrackHistEfficiency->GetGrid(step))
      continue;
    
    Printf("Eff: Copying step %d", step);
    THnSparse* target = fTrackHistEfficiency->GetGrid(step)->GetGrid();
    THnSparse* source = from->fTrackHistEfficiency->GetGrid(step)->GetGrid();

    target->Reset();
    target->RebinnedAdd(source);
  }
}

void AliUEHist::SymmetrizepTBins()
{
  // copy pt,a < pt,t bins to pt,a > pt,t (inverting deltaphi and delta eta as it should be) including symmetric bins
  
  for (Int_t region=0; region<4; region++)
  {
    if (!fTrackHist[region])
      continue;
  
    for (Int_t step=0; step<fTrackHist[region]->GetNStep(); step++)
    {
      Printf("Copying region %d step %d", region, step);
      THnSparse* target = fTrackHist[region]->GetGrid(step)->GetGrid();
      if (target->GetEntries() == 0)
	continue;
      
      // for symmetric bins
      THnSparse* source = (THnSparse*) target->Clone();
      
      Int_t zVtxBins = 1;
      if (target->GetNdimensions() > 5)
	zVtxBins = target->GetAxis(5)->GetNbins();
      
      // axes: 0 delta eta; 1 pT,a; 2 pT,t; 3 centrality; 4 delta phi; 5 vtx-z
      for (Int_t i3 = 1; i3 <= target->GetAxis(3)->GetNbins(); i3++)
	for (Int_t i5 = 1; i5 <= zVtxBins; i5++)
	{
	  for (Int_t i1 = 1; i1 <= target->GetAxis(1)->GetNbins(); i1++)
	    for (Int_t i2 = 1; i2 <= target->GetAxis(2)->GetNbins(); i2++)
	    {
	      // find source bin
	      Int_t binA = target->GetAxis(1)->FindBin(target->GetAxis(2)->GetBinCenter(i2));
	      Int_t binT = target->GetAxis(2)->FindBin(target->GetAxis(1)->GetBinCenter(i1));
	      
	      Printf("(%d %d) Copying from %d %d to %d %d", i3, i5, binA, binT, i1, i2);
	      
	      for (Int_t i0 = 1; i0 <= target->GetAxis(0)->GetNbins(); i0++)
		for (Int_t i4 = 1; i4 <= target->GetAxis(4)->GetNbins(); i4++)
		{
		  Int_t binEta = target->GetAxis(0)->FindBin(-target->GetAxis(0)->GetBinCenter(i0));
		  Double_t phi = -target->GetAxis(4)->GetBinCenter(i4);
		  if (phi < -TMath::Pi()/2)
		    phi += TMath::TwoPi();
		  Int_t binPhi = target->GetAxis(4)->FindBin(phi);
		  
		  Int_t binSource[] = { binEta, binA, binT, i3, binPhi, i5 };
		  Int_t binTarget[] = { i0, i1, i2, i3, i4, i5 };
		  
		  Double_t value = source->GetBinContent(binSource);
		  Double_t error = source->GetBinError(binSource);
		  
		  if (error == 0)
		    continue;
		  
		  Double_t value2 = target->GetBinContent(binTarget);
		  Double_t error2 = target->GetBinError(binTarget);
		  
		  Double_t sum = value;
		  Double_t err = error;
		  
		  if (error2 > 0)
		  {
		    sum = value + value2;
		    err = TMath::Sqrt(error * error + error2 * error2);
		  }

		  // Printf("  Values: %f +- %f; %f +- %f --> %f +- %f", value, error, value2, error2, sum, err);
		  
		  target->SetBinContent(binTarget, sum);
		  target->SetBinError(binTarget, err);
		}
	    }
	}
	
	delete source;
    }
  }
}

//____________________________________________________________________
void AliUEHist::ExtendTrackingEfficiency(Bool_t verbose)
{
  // fits the tracking efficiency at high pT with a constant and fills all bins with this tracking efficiency

  Float_t fitRangeBegin = 5.01;
  Float_t fitRangeEnd = 14.99;
  Float_t extendRangeBegin = 10.01;

  if (fTrackHistEfficiency->GetNVar() == 3)
  {
    TH1* obj = GetTrackingEfficiency(1);
  
    if (verbose)
    {
      new TCanvas; 
      obj->Draw();
    }
    
    obj->Fit("pol0", (verbose) ? "+" : "0+", "SAME", fitRangeBegin, fitRangeEnd);
  
    Float_t trackingEff = obj->GetFunction("pol0")->GetParameter(0);
  
    obj = GetTrackingContamination(1);
  
    if (verbose)
    {
      new TCanvas; 
      obj->Draw();
    }
    
    obj->Fit("pol0", (verbose) ? "+" : "0+", "SAME", fitRangeBegin, fitRangeEnd);
  
    Float_t trackingCont = obj->GetFunction("pol0")->GetParameter(0);
  
    Printf("AliUEHist::ExtendTrackingEfficiency: Fitted efficiency between %f and %f and got %f tracking efficiency and %f tracking contamination correction. Extending from %f onwards (within %f < eta < %f)", fitRangeBegin, fitRangeEnd, trackingEff, trackingCont, extendRangeBegin, fEtaMin, fEtaMax);
  
    // extend for full pT range
    for (Int_t x = fTrackHistEfficiency->GetAxis(0, 0)->FindBin(fEtaMin); x <= fTrackHistEfficiency->GetAxis(0, 0)->FindBin(fEtaMax); x++)
      for (Int_t y = fTrackHistEfficiency->GetAxis(1, 0)->FindBin(extendRangeBegin); y <= fTrackHistEfficiency->GetNBins(1); y++)
        for (Int_t z = 1; z <= fTrackHistEfficiency->GetNBins(2); z++) // particle type axis
        {
          
          Int_t bins[3];
          bins[0] = x;
          bins[1] = y;
          bins[2] = z;
          
          fTrackHistEfficiency->GetGrid(0)->SetElement(bins, 100);
          fTrackHistEfficiency->GetGrid(1)->SetElement(bins, 100.0 * trackingEff);
          fTrackHistEfficiency->GetGrid(2)->SetElement(bins, 100.0 * trackingEff / trackingCont);
        }
  }
  else if (fTrackHistEfficiency->GetNVar() == 4)
  {
    // fit in centrality intervals of 20% for efficiency, one bin for contamination
    Float_t* trackingEff = 0;
    Float_t* trackingCont = 0;
    Float_t centralityBins[] = { 0, 10, 20, 40, 60, 100 };
    Int_t nCentralityBins = 5;
    
    Printf("AliUEHist::ExtendTrackingEfficiency: Fitting efficiencies between %f and %f. Extending from %f onwards (within %f < eta < %f)", fitRangeBegin, fitRangeEnd, extendRangeBegin, fEtaMin, fEtaMax);
    
    // 0 = eff; 1 = cont
    for (Int_t caseNo = 0; caseNo < 2; caseNo++)
    {
      Float_t* target = 0;
      Int_t centralityBinsLocal = nCentralityBins;
      
      if (caseNo == 0)
      {
        trackingEff = new Float_t[centralityBinsLocal];
        target = trackingEff;
      }
      else
      {
        centralityBinsLocal = 1;
        trackingCont = new Float_t[centralityBinsLocal];
        target = trackingCont;
      }
    
      for (Int_t i=0; i<centralityBinsLocal; i++)
      {
	if (centralityBinsLocal == 1)
	  SetCentralityRange(centralityBins[0] + 0.1, centralityBins[nCentralityBins] - 0.1);
	else
	  SetCentralityRange(centralityBins[i] + 0.1, centralityBins[i+1] - 0.1);
        TH1* proj = (caseNo == 0) ? GetTrackingEfficiency(1) : GetTrackingContamination(1);
        if (verbose)
        {
          new TCanvas;
          proj->DrawCopy();
        }
        if ((Int_t) proj->Fit("pol0", (verbose) ? "+" : "Q0+", "SAME", fitRangeBegin, fitRangeEnd) == 0)
          target[i] = proj->GetFunction("pol0")->GetParameter(0);
        else
          target[i] = 0;
        Printf("AliUEHist::ExtendTrackingEfficiency: case %d, centrality %d, eff %f", caseNo, i, target[i]);
      }
    }
  
    // extend for full pT range
    for (Int_t x = fTrackHistEfficiency->GetAxis(0, 0)->FindBin(fEtaMin); x <= fTrackHistEfficiency->GetAxis(0, 0)->FindBin(fEtaMax); x++)
      for (Int_t y = fTrackHistEfficiency->GetAxis(1, 0)->FindBin(extendRangeBegin); y <= fTrackHistEfficiency->GetNBins(1); y++)
        for (Int_t z = 1; z <= fTrackHistEfficiency->GetNBins(2); z++) // particle type axis
        {
          for (Int_t z2 = 1; z2 <= fTrackHistEfficiency->GetNBins(3); z2++) // centrality axis
          {
            
            Int_t bins[4];
            bins[0] = x;
            bins[1] = y;
            bins[2] = z;
            bins[3] = z2;
            
            Int_t z2Bin = 0;
	    while (centralityBins[z2Bin+1] < fTrackHistEfficiency->GetAxis(3, 0)->GetBinCenter(z2))
	      z2Bin++;
	    
            //Printf("%d %d", z2, z2Bin);
            
            fTrackHistEfficiency->GetGrid(0)->SetElement(bins, 100);
            fTrackHistEfficiency->GetGrid(1)->SetElement(bins, 100.0 * trackingEff[z2Bin]);
            if (trackingCont[0] > 0)
              fTrackHistEfficiency->GetGrid(2)->SetElement(bins, 100.0 * trackingEff[z2Bin] / trackingCont[0]);
            else  
              fTrackHistEfficiency->GetGrid(2)->SetElement(bins, 0);
          }
       }
       
     delete[] trackingEff;
     delete[] trackingCont;
   }
   
   SetCentralityRange(0, 0);
}

void AliUEHist::AdditionalDPhiCorrection(Int_t step)
{
  // corrects the dphi distribution with an extra factor close to dphi ~ 0

  Printf("WARNING: In AliUEHist::AdditionalDPhiCorrection.");

  THnSparse* grid = fTrackHist[0]->GetGrid(step)->GetGrid();
  
  // optimized implementation
  for (Int_t binIdx = 0; binIdx < grid->GetNbins(); binIdx++)
  {
    Int_t bins[6];
    Double_t value = grid->GetBinContent(binIdx, bins);
    Double_t error = grid->GetBinError(binIdx);
    
    Float_t binCenter = grid->GetAxis(4)->GetBinCenter(bins[4]);
    if (TMath::Abs(binCenter) < 0.2)
    {
      value *= 0.985;
      error *= 0.985;
    }
    else if (TMath::Abs(binCenter) < 0.3)
    {
      value *= 0.9925;
      error *= 0.9925;
    }
    
    grid->SetBinContent(bins, value);
    grid->SetBinError(bins, error);
  }
}

void AliUEHist::Scale(Double_t factor)
{
  // scales all contained histograms by the given factor
  
  for (Int_t i=0; i<4; i++)
    if (fTrackHist[i])
      fTrackHist[i]->Scale(factor);
  
  fEventHist->Scale(factor);
  fTrackHistEfficiency->Scale(factor);
}

void AliUEHist::Reset()
{
  // resets all contained histograms
  
  for (Int_t i=0; i<4; i++)
    if (fTrackHist[i])
      for (Int_t step=0; step<fTrackHist[i]->GetNStep(); step++)
        fTrackHist[i]->GetGrid(step)->GetGrid()->Reset();
  
  for (Int_t step=0; step<fEventHist->GetNStep(); step++)
    fEventHist->GetGrid(step)->GetGrid()->Reset();
    
  for (Int_t step=0; step<fTrackHistEfficiency->GetNStep(); step++)
    fTrackHistEfficiency->GetGrid(step)->GetGrid()->Reset();
}

THnBase* AliUEHist::ChangeToThn(THnBase* sparse)
{
  // change the object to THn for faster processing
  
	// convert to THn (SEGV's for some strange reason...) 
	// x = THn::CreateHn("a", "a", sparse);
	
  // own implementation
  Int_t nBins[10];
  for (Int_t i=0; i<sparse->GetNdimensions(); i++)
    nBins[i] = sparse->GetAxis(i)->GetNbins();
  THn* tmpTHn = new THnF(Form("%s_thn", sparse->GetName()), sparse->GetTitle(), sparse->GetNdimensions(), nBins, 0, 0);
  for (Int_t i=0; i<sparse->GetNdimensions(); i++)
  {
    tmpTHn->SetBinEdges(i, sparse->GetAxis(i)->GetXbins()->GetArray());
    tmpTHn->GetAxis(i)->SetTitle(sparse->GetAxis(i)->GetTitle());
  }
  tmpTHn->RebinnedAdd(sparse);
  
  return tmpTHn;
}

void AliUEHist::CondenseBin(THnSparse* grid, THnSparse* target, Int_t axis, Float_t targetValue, Float_t from, Float_t to)
{
  //
  // loops through the histogram and moves all entries to a single point <targetValue> on the axis <axis>
  // if <from> and <to> are set, then moving only occurs if value on <axis> is betweem <from> and <to>
  //

  if (grid->GetNdimensions() > 6)
    AliFatal("Too many dimensions in THnSparse");
  
  Int_t targetBin = grid->GetAxis(axis)->FindBin(targetValue);
  AliInfo(Form("Target bin on axis %d with value %f is %d", axis, targetValue, targetBin));
  
  Int_t fromBin = 1;
  Int_t toBin = grid->GetAxis(axis)->GetNbins();
  if (to > from)
  {
    fromBin = grid->GetAxis(axis)->FindBin(from);
    toBin = grid->GetAxis(axis)->FindBin(to);
    AliInfo(Form("Only condensing between bin %d and %d", fromBin, toBin));
  }
  
  Int_t bins[6];
  for (Int_t binIdx = 0; binIdx < grid->GetNbins(); binIdx++)
  {
    Double_t value = grid->GetBinContent(binIdx, bins);
    Double_t error = grid->GetBinError(binIdx);
    
    if (bins[axis] >= fromBin && bins[axis] <= toBin)
      bins[axis] = targetBin;

    value += target->GetBinContent(bins);
    error = TMath::Sqrt(error * error + target->GetBinError(bins) * target->GetBinError(bins));
    
    target->SetBinContent(bins, value);
    target->SetBinError(bins, error);
  }
}

void AliUEHist::CondenseBin(CFStep step, Int_t trackAxis, Int_t eventAxis, Float_t targetValue, Float_t from, Float_t to, CFStep tmpStep)
{
  // loops through the histogram at <step> and moves all entries to a single point <targetValue> on the axes 
  // <trackAxis> and <eventAxis>. <tmpStep> is used to temporary store the data
  // This is useful e.g. to move bin content around for MC productions where the centrality selection did
  // not yield the desired result

  // reset tmpStep
  fEventHist->GetGrid(tmpStep)->GetGrid()->Reset();
  for (UInt_t i=0; i<fkRegions; i++)
    if (fTrackHist[i])
      fTrackHist[i]->GetGrid(tmpStep)->GetGrid()->Reset();

  // copy to tmpStep
  CorrectTracks(step, tmpStep, 0, -1);
  CorrectEvents(step, tmpStep, 0, -1);

  // reset step
  fEventHist->GetGrid(step)->GetGrid()->Reset();
  for (UInt_t i=0; i<fkRegions; i++)
    if (fTrackHist[i])
      fTrackHist[i]->GetGrid(step)->GetGrid()->Reset();
  
  // rewriting
  for (UInt_t i=0; i<fkRegions; i++)
  {
    if (!fTrackHist[i])
      continue;
    
    THnSparse* grid = fTrackHist[i]->GetGrid(tmpStep)->GetGrid();
    THnSparse* target = fTrackHist[i]->GetGrid(step)->GetGrid();
    
    CondenseBin(grid, target, trackAxis, targetValue, from, to);
  }
  CondenseBin(fEventHist->GetGrid(tmpStep)->GetGrid(), fEventHist->GetGrid(step)->GetGrid(), eventAxis, targetValue, from, to);
  
  // reset tmpStep
  fEventHist->GetGrid(tmpStep)->GetGrid()->Reset();
  for (UInt_t i=0; i<fkRegions; i++)
    if (fTrackHist[i])
      fTrackHist[i]->GetGrid(tmpStep)->GetGrid()->Reset();
}
 AliUEHist.cxx:1
 AliUEHist.cxx:2
 AliUEHist.cxx:3
 AliUEHist.cxx:4
 AliUEHist.cxx:5
 AliUEHist.cxx:6
 AliUEHist.cxx:7
 AliUEHist.cxx:8
 AliUEHist.cxx:9
 AliUEHist.cxx:10
 AliUEHist.cxx:11
 AliUEHist.cxx:12
 AliUEHist.cxx:13
 AliUEHist.cxx:14
 AliUEHist.cxx:15
 AliUEHist.cxx:16
 AliUEHist.cxx:17
 AliUEHist.cxx:18
 AliUEHist.cxx:19
 AliUEHist.cxx:20
 AliUEHist.cxx:21
 AliUEHist.cxx:22
 AliUEHist.cxx:23
 AliUEHist.cxx:24
 AliUEHist.cxx:25
 AliUEHist.cxx:26
 AliUEHist.cxx:27
 AliUEHist.cxx:28
 AliUEHist.cxx:29
 AliUEHist.cxx:30
 AliUEHist.cxx:31
 AliUEHist.cxx:32
 AliUEHist.cxx:33
 AliUEHist.cxx:34
 AliUEHist.cxx:35
 AliUEHist.cxx:36
 AliUEHist.cxx:37
 AliUEHist.cxx:38
 AliUEHist.cxx:39
 AliUEHist.cxx:40
 AliUEHist.cxx:41
 AliUEHist.cxx:42
 AliUEHist.cxx:43
 AliUEHist.cxx:44
 AliUEHist.cxx:45
 AliUEHist.cxx:46
 AliUEHist.cxx:47
 AliUEHist.cxx:48
 AliUEHist.cxx:49
 AliUEHist.cxx:50
 AliUEHist.cxx:51
 AliUEHist.cxx:52
 AliUEHist.cxx:53
 AliUEHist.cxx:54
 AliUEHist.cxx:55
 AliUEHist.cxx:56
 AliUEHist.cxx:57
 AliUEHist.cxx:58
 AliUEHist.cxx:59
 AliUEHist.cxx:60
 AliUEHist.cxx:61
 AliUEHist.cxx:62
 AliUEHist.cxx:63
 AliUEHist.cxx:64
 AliUEHist.cxx:65
 AliUEHist.cxx:66
 AliUEHist.cxx:67
 AliUEHist.cxx:68
 AliUEHist.cxx:69
 AliUEHist.cxx:70
 AliUEHist.cxx:71
 AliUEHist.cxx:72
 AliUEHist.cxx:73
 AliUEHist.cxx:74
 AliUEHist.cxx:75
 AliUEHist.cxx:76
 AliUEHist.cxx:77
 AliUEHist.cxx:78
 AliUEHist.cxx:79
 AliUEHist.cxx:80
 AliUEHist.cxx:81
 AliUEHist.cxx:82
 AliUEHist.cxx:83
 AliUEHist.cxx:84
 AliUEHist.cxx:85
 AliUEHist.cxx:86
 AliUEHist.cxx:87
 AliUEHist.cxx:88
 AliUEHist.cxx:89
 AliUEHist.cxx:90
 AliUEHist.cxx:91
 AliUEHist.cxx:92
 AliUEHist.cxx:93
 AliUEHist.cxx:94
 AliUEHist.cxx:95
 AliUEHist.cxx:96
 AliUEHist.cxx:97
 AliUEHist.cxx:98
 AliUEHist.cxx:99
 AliUEHist.cxx:100
 AliUEHist.cxx:101
 AliUEHist.cxx:102
 AliUEHist.cxx:103
 AliUEHist.cxx:104
 AliUEHist.cxx:105
 AliUEHist.cxx:106
 AliUEHist.cxx:107
 AliUEHist.cxx:108
 AliUEHist.cxx:109
 AliUEHist.cxx:110
 AliUEHist.cxx:111
 AliUEHist.cxx:112
 AliUEHist.cxx:113
 AliUEHist.cxx:114
 AliUEHist.cxx:115
 AliUEHist.cxx:116
 AliUEHist.cxx:117
 AliUEHist.cxx:118
 AliUEHist.cxx:119
 AliUEHist.cxx:120
 AliUEHist.cxx:121
 AliUEHist.cxx:122
 AliUEHist.cxx:123
 AliUEHist.cxx:124
 AliUEHist.cxx:125
 AliUEHist.cxx:126
 AliUEHist.cxx:127
 AliUEHist.cxx:128
 AliUEHist.cxx:129
 AliUEHist.cxx:130
 AliUEHist.cxx:131
 AliUEHist.cxx:132
 AliUEHist.cxx:133
 AliUEHist.cxx:134
 AliUEHist.cxx:135
 AliUEHist.cxx:136
 AliUEHist.cxx:137
 AliUEHist.cxx:138
 AliUEHist.cxx:139
 AliUEHist.cxx:140
 AliUEHist.cxx:141
 AliUEHist.cxx:142
 AliUEHist.cxx:143
 AliUEHist.cxx:144
 AliUEHist.cxx:145
 AliUEHist.cxx:146
 AliUEHist.cxx:147
 AliUEHist.cxx:148
 AliUEHist.cxx:149
 AliUEHist.cxx:150
 AliUEHist.cxx:151
 AliUEHist.cxx:152
 AliUEHist.cxx:153
 AliUEHist.cxx:154
 AliUEHist.cxx:155
 AliUEHist.cxx:156
 AliUEHist.cxx:157
 AliUEHist.cxx:158
 AliUEHist.cxx:159
 AliUEHist.cxx:160
 AliUEHist.cxx:161
 AliUEHist.cxx:162
 AliUEHist.cxx:163
 AliUEHist.cxx:164
 AliUEHist.cxx:165
 AliUEHist.cxx:166
 AliUEHist.cxx:167
 AliUEHist.cxx:168
 AliUEHist.cxx:169
 AliUEHist.cxx:170
 AliUEHist.cxx:171
 AliUEHist.cxx:172
 AliUEHist.cxx:173
 AliUEHist.cxx:174
 AliUEHist.cxx:175
 AliUEHist.cxx:176
 AliUEHist.cxx:177
 AliUEHist.cxx:178
 AliUEHist.cxx:179
 AliUEHist.cxx:180
 AliUEHist.cxx:181
 AliUEHist.cxx:182
 AliUEHist.cxx:183
 AliUEHist.cxx:184
 AliUEHist.cxx:185
 AliUEHist.cxx:186
 AliUEHist.cxx:187
 AliUEHist.cxx:188
 AliUEHist.cxx:189
 AliUEHist.cxx:190
 AliUEHist.cxx:191
 AliUEHist.cxx:192
 AliUEHist.cxx:193
 AliUEHist.cxx:194
 AliUEHist.cxx:195
 AliUEHist.cxx:196
 AliUEHist.cxx:197
 AliUEHist.cxx:198
 AliUEHist.cxx:199
 AliUEHist.cxx:200
 AliUEHist.cxx:201
 AliUEHist.cxx:202
 AliUEHist.cxx:203
 AliUEHist.cxx:204
 AliUEHist.cxx:205
 AliUEHist.cxx:206
 AliUEHist.cxx:207
 AliUEHist.cxx:208
 AliUEHist.cxx:209
 AliUEHist.cxx:210
 AliUEHist.cxx:211
 AliUEHist.cxx:212
 AliUEHist.cxx:213
 AliUEHist.cxx:214
 AliUEHist.cxx:215
 AliUEHist.cxx:216
 AliUEHist.cxx:217
 AliUEHist.cxx:218
 AliUEHist.cxx:219
 AliUEHist.cxx:220
 AliUEHist.cxx:221
 AliUEHist.cxx:222
 AliUEHist.cxx:223
 AliUEHist.cxx:224
 AliUEHist.cxx:225
 AliUEHist.cxx:226
 AliUEHist.cxx:227
 AliUEHist.cxx:228
 AliUEHist.cxx:229
 AliUEHist.cxx:230
 AliUEHist.cxx:231
 AliUEHist.cxx:232
 AliUEHist.cxx:233
 AliUEHist.cxx:234
 AliUEHist.cxx:235
 AliUEHist.cxx:236
 AliUEHist.cxx:237
 AliUEHist.cxx:238
 AliUEHist.cxx:239
 AliUEHist.cxx:240
 AliUEHist.cxx:241
 AliUEHist.cxx:242
 AliUEHist.cxx:243
 AliUEHist.cxx:244
 AliUEHist.cxx:245
 AliUEHist.cxx:246
 AliUEHist.cxx:247
 AliUEHist.cxx:248
 AliUEHist.cxx:249
 AliUEHist.cxx:250
 AliUEHist.cxx:251
 AliUEHist.cxx:252
 AliUEHist.cxx:253
 AliUEHist.cxx:254
 AliUEHist.cxx:255
 AliUEHist.cxx:256
 AliUEHist.cxx:257
 AliUEHist.cxx:258
 AliUEHist.cxx:259
 AliUEHist.cxx:260
 AliUEHist.cxx:261
 AliUEHist.cxx:262
 AliUEHist.cxx:263
 AliUEHist.cxx:264
 AliUEHist.cxx:265
 AliUEHist.cxx:266
 AliUEHist.cxx:267
 AliUEHist.cxx:268
 AliUEHist.cxx:269
 AliUEHist.cxx:270
 AliUEHist.cxx:271
 AliUEHist.cxx:272
 AliUEHist.cxx:273
 AliUEHist.cxx:274
 AliUEHist.cxx:275
 AliUEHist.cxx:276
 AliUEHist.cxx:277
 AliUEHist.cxx:278
 AliUEHist.cxx:279
 AliUEHist.cxx:280
 AliUEHist.cxx:281
 AliUEHist.cxx:282
 AliUEHist.cxx:283
 AliUEHist.cxx:284
 AliUEHist.cxx:285
 AliUEHist.cxx:286
 AliUEHist.cxx:287
 AliUEHist.cxx:288
 AliUEHist.cxx:289
 AliUEHist.cxx:290
 AliUEHist.cxx:291
 AliUEHist.cxx:292
 AliUEHist.cxx:293
 AliUEHist.cxx:294
 AliUEHist.cxx:295
 AliUEHist.cxx:296
 AliUEHist.cxx:297
 AliUEHist.cxx:298
 AliUEHist.cxx:299
 AliUEHist.cxx:300
 AliUEHist.cxx:301
 AliUEHist.cxx:302
 AliUEHist.cxx:303
 AliUEHist.cxx:304
 AliUEHist.cxx:305
 AliUEHist.cxx:306
 AliUEHist.cxx:307
 AliUEHist.cxx:308
 AliUEHist.cxx:309
 AliUEHist.cxx:310
 AliUEHist.cxx:311
 AliUEHist.cxx:312
 AliUEHist.cxx:313
 AliUEHist.cxx:314
 AliUEHist.cxx:315
 AliUEHist.cxx:316
 AliUEHist.cxx:317
 AliUEHist.cxx:318
 AliUEHist.cxx:319
 AliUEHist.cxx:320
 AliUEHist.cxx:321
 AliUEHist.cxx:322
 AliUEHist.cxx:323
 AliUEHist.cxx:324
 AliUEHist.cxx:325
 AliUEHist.cxx:326
 AliUEHist.cxx:327
 AliUEHist.cxx:328
 AliUEHist.cxx:329
 AliUEHist.cxx:330
 AliUEHist.cxx:331
 AliUEHist.cxx:332
 AliUEHist.cxx:333
 AliUEHist.cxx:334
 AliUEHist.cxx:335
 AliUEHist.cxx:336
 AliUEHist.cxx:337
 AliUEHist.cxx:338
 AliUEHist.cxx:339
 AliUEHist.cxx:340
 AliUEHist.cxx:341
 AliUEHist.cxx:342
 AliUEHist.cxx:343
 AliUEHist.cxx:344
 AliUEHist.cxx:345
 AliUEHist.cxx:346
 AliUEHist.cxx:347
 AliUEHist.cxx:348
 AliUEHist.cxx:349
 AliUEHist.cxx:350
 AliUEHist.cxx:351
 AliUEHist.cxx:352
 AliUEHist.cxx:353
 AliUEHist.cxx:354
 AliUEHist.cxx:355
 AliUEHist.cxx:356
 AliUEHist.cxx:357
 AliUEHist.cxx:358
 AliUEHist.cxx:359
 AliUEHist.cxx:360
 AliUEHist.cxx:361
 AliUEHist.cxx:362
 AliUEHist.cxx:363
 AliUEHist.cxx:364
 AliUEHist.cxx:365
 AliUEHist.cxx:366
 AliUEHist.cxx:367
 AliUEHist.cxx:368
 AliUEHist.cxx:369
 AliUEHist.cxx:370
 AliUEHist.cxx:371
 AliUEHist.cxx:372
 AliUEHist.cxx:373
 AliUEHist.cxx:374
 AliUEHist.cxx:375
 AliUEHist.cxx:376
 AliUEHist.cxx:377
 AliUEHist.cxx:378
 AliUEHist.cxx:379
 AliUEHist.cxx:380
 AliUEHist.cxx:381
 AliUEHist.cxx:382
 AliUEHist.cxx:383
 AliUEHist.cxx:384
 AliUEHist.cxx:385
 AliUEHist.cxx:386
 AliUEHist.cxx:387
 AliUEHist.cxx:388
 AliUEHist.cxx:389
 AliUEHist.cxx:390
 AliUEHist.cxx:391
 AliUEHist.cxx:392
 AliUEHist.cxx:393
 AliUEHist.cxx:394
 AliUEHist.cxx:395
 AliUEHist.cxx:396
 AliUEHist.cxx:397
 AliUEHist.cxx:398
 AliUEHist.cxx:399
 AliUEHist.cxx:400
 AliUEHist.cxx:401
 AliUEHist.cxx:402
 AliUEHist.cxx:403
 AliUEHist.cxx:404
 AliUEHist.cxx:405
 AliUEHist.cxx:406
 AliUEHist.cxx:407
 AliUEHist.cxx:408
 AliUEHist.cxx:409
 AliUEHist.cxx:410
 AliUEHist.cxx:411
 AliUEHist.cxx:412
 AliUEHist.cxx:413
 AliUEHist.cxx:414
 AliUEHist.cxx:415
 AliUEHist.cxx:416
 AliUEHist.cxx:417
 AliUEHist.cxx:418
 AliUEHist.cxx:419
 AliUEHist.cxx:420
 AliUEHist.cxx:421
 AliUEHist.cxx:422
 AliUEHist.cxx:423
 AliUEHist.cxx:424
 AliUEHist.cxx:425
 AliUEHist.cxx:426
 AliUEHist.cxx:427
 AliUEHist.cxx:428
 AliUEHist.cxx:429
 AliUEHist.cxx:430
 AliUEHist.cxx:431
 AliUEHist.cxx:432
 AliUEHist.cxx:433
 AliUEHist.cxx:434
 AliUEHist.cxx:435
 AliUEHist.cxx:436
 AliUEHist.cxx:437
 AliUEHist.cxx:438
 AliUEHist.cxx:439
 AliUEHist.cxx:440
 AliUEHist.cxx:441
 AliUEHist.cxx:442
 AliUEHist.cxx:443
 AliUEHist.cxx:444
 AliUEHist.cxx:445
 AliUEHist.cxx:446
 AliUEHist.cxx:447
 AliUEHist.cxx:448
 AliUEHist.cxx:449
 AliUEHist.cxx:450
 AliUEHist.cxx:451
 AliUEHist.cxx:452
 AliUEHist.cxx:453
 AliUEHist.cxx:454
 AliUEHist.cxx:455
 AliUEHist.cxx:456
 AliUEHist.cxx:457
 AliUEHist.cxx:458
 AliUEHist.cxx:459
 AliUEHist.cxx:460
 AliUEHist.cxx:461
 AliUEHist.cxx:462
 AliUEHist.cxx:463
 AliUEHist.cxx:464
 AliUEHist.cxx:465
 AliUEHist.cxx:466
 AliUEHist.cxx:467
 AliUEHist.cxx:468
 AliUEHist.cxx:469
 AliUEHist.cxx:470
 AliUEHist.cxx:471
 AliUEHist.cxx:472
 AliUEHist.cxx:473
 AliUEHist.cxx:474
 AliUEHist.cxx:475
 AliUEHist.cxx:476
 AliUEHist.cxx:477
 AliUEHist.cxx:478
 AliUEHist.cxx:479
 AliUEHist.cxx:480
 AliUEHist.cxx:481
 AliUEHist.cxx:482
 AliUEHist.cxx:483
 AliUEHist.cxx:484
 AliUEHist.cxx:485
 AliUEHist.cxx:486
 AliUEHist.cxx:487
 AliUEHist.cxx:488
 AliUEHist.cxx:489
 AliUEHist.cxx:490
 AliUEHist.cxx:491
 AliUEHist.cxx:492
 AliUEHist.cxx:493
 AliUEHist.cxx:494
 AliUEHist.cxx:495
 AliUEHist.cxx:496
 AliUEHist.cxx:497
 AliUEHist.cxx:498
 AliUEHist.cxx:499
 AliUEHist.cxx:500
 AliUEHist.cxx:501
 AliUEHist.cxx:502
 AliUEHist.cxx:503
 AliUEHist.cxx:504
 AliUEHist.cxx:505
 AliUEHist.cxx:506
 AliUEHist.cxx:507
 AliUEHist.cxx:508
 AliUEHist.cxx:509
 AliUEHist.cxx:510
 AliUEHist.cxx:511
 AliUEHist.cxx:512
 AliUEHist.cxx:513
 AliUEHist.cxx:514
 AliUEHist.cxx:515
 AliUEHist.cxx:516
 AliUEHist.cxx:517
 AliUEHist.cxx:518
 AliUEHist.cxx:519
 AliUEHist.cxx:520
 AliUEHist.cxx:521
 AliUEHist.cxx:522
 AliUEHist.cxx:523
 AliUEHist.cxx:524
 AliUEHist.cxx:525
 AliUEHist.cxx:526
 AliUEHist.cxx:527
 AliUEHist.cxx:528
 AliUEHist.cxx:529
 AliUEHist.cxx:530
 AliUEHist.cxx:531
 AliUEHist.cxx:532
 AliUEHist.cxx:533
 AliUEHist.cxx:534
 AliUEHist.cxx:535
 AliUEHist.cxx:536
 AliUEHist.cxx:537
 AliUEHist.cxx:538
 AliUEHist.cxx:539
 AliUEHist.cxx:540
 AliUEHist.cxx:541
 AliUEHist.cxx:542
 AliUEHist.cxx:543
 AliUEHist.cxx:544
 AliUEHist.cxx:545
 AliUEHist.cxx:546
 AliUEHist.cxx:547
 AliUEHist.cxx:548
 AliUEHist.cxx:549
 AliUEHist.cxx:550
 AliUEHist.cxx:551
 AliUEHist.cxx:552
 AliUEHist.cxx:553
 AliUEHist.cxx:554
 AliUEHist.cxx:555
 AliUEHist.cxx:556
 AliUEHist.cxx:557
 AliUEHist.cxx:558
 AliUEHist.cxx:559
 AliUEHist.cxx:560
 AliUEHist.cxx:561
 AliUEHist.cxx:562
 AliUEHist.cxx:563
 AliUEHist.cxx:564
 AliUEHist.cxx:565
 AliUEHist.cxx:566
 AliUEHist.cxx:567
 AliUEHist.cxx:568
 AliUEHist.cxx:569
 AliUEHist.cxx:570
 AliUEHist.cxx:571
 AliUEHist.cxx:572
 AliUEHist.cxx:573
 AliUEHist.cxx:574
 AliUEHist.cxx:575
 AliUEHist.cxx:576
 AliUEHist.cxx:577
 AliUEHist.cxx:578
 AliUEHist.cxx:579
 AliUEHist.cxx:580
 AliUEHist.cxx:581
 AliUEHist.cxx:582
 AliUEHist.cxx:583
 AliUEHist.cxx:584
 AliUEHist.cxx:585
 AliUEHist.cxx:586
 AliUEHist.cxx:587
 AliUEHist.cxx:588
 AliUEHist.cxx:589
 AliUEHist.cxx:590
 AliUEHist.cxx:591
 AliUEHist.cxx:592
 AliUEHist.cxx:593
 AliUEHist.cxx:594
 AliUEHist.cxx:595
 AliUEHist.cxx:596
 AliUEHist.cxx:597
 AliUEHist.cxx:598
 AliUEHist.cxx:599
 AliUEHist.cxx:600
 AliUEHist.cxx:601
 AliUEHist.cxx:602
 AliUEHist.cxx:603
 AliUEHist.cxx:604
 AliUEHist.cxx:605
 AliUEHist.cxx:606
 AliUEHist.cxx:607
 AliUEHist.cxx:608
 AliUEHist.cxx:609
 AliUEHist.cxx:610
 AliUEHist.cxx:611
 AliUEHist.cxx:612
 AliUEHist.cxx:613
 AliUEHist.cxx:614
 AliUEHist.cxx:615
 AliUEHist.cxx:616
 AliUEHist.cxx:617
 AliUEHist.cxx:618
 AliUEHist.cxx:619
 AliUEHist.cxx:620
 AliUEHist.cxx:621
 AliUEHist.cxx:622
 AliUEHist.cxx:623
 AliUEHist.cxx:624
 AliUEHist.cxx:625
 AliUEHist.cxx:626
 AliUEHist.cxx:627
 AliUEHist.cxx:628
 AliUEHist.cxx:629
 AliUEHist.cxx:630
 AliUEHist.cxx:631
 AliUEHist.cxx:632
 AliUEHist.cxx:633
 AliUEHist.cxx:634
 AliUEHist.cxx:635
 AliUEHist.cxx:636
 AliUEHist.cxx:637
 AliUEHist.cxx:638
 AliUEHist.cxx:639
 AliUEHist.cxx:640
 AliUEHist.cxx:641
 AliUEHist.cxx:642
 AliUEHist.cxx:643
 AliUEHist.cxx:644
 AliUEHist.cxx:645
 AliUEHist.cxx:646
 AliUEHist.cxx:647
 AliUEHist.cxx:648
 AliUEHist.cxx:649
 AliUEHist.cxx:650
 AliUEHist.cxx:651
 AliUEHist.cxx:652
 AliUEHist.cxx:653
 AliUEHist.cxx:654
 AliUEHist.cxx:655
 AliUEHist.cxx:656
 AliUEHist.cxx:657
 AliUEHist.cxx:658
 AliUEHist.cxx:659
 AliUEHist.cxx:660
 AliUEHist.cxx:661
 AliUEHist.cxx:662
 AliUEHist.cxx:663
 AliUEHist.cxx:664
 AliUEHist.cxx:665
 AliUEHist.cxx:666
 AliUEHist.cxx:667
 AliUEHist.cxx:668
 AliUEHist.cxx:669
 AliUEHist.cxx:670
 AliUEHist.cxx:671
 AliUEHist.cxx:672
 AliUEHist.cxx:673
 AliUEHist.cxx:674
 AliUEHist.cxx:675
 AliUEHist.cxx:676
 AliUEHist.cxx:677
 AliUEHist.cxx:678
 AliUEHist.cxx:679
 AliUEHist.cxx:680
 AliUEHist.cxx:681
 AliUEHist.cxx:682
 AliUEHist.cxx:683
 AliUEHist.cxx:684
 AliUEHist.cxx:685
 AliUEHist.cxx:686
 AliUEHist.cxx:687
 AliUEHist.cxx:688
 AliUEHist.cxx:689
 AliUEHist.cxx:690
 AliUEHist.cxx:691
 AliUEHist.cxx:692
 AliUEHist.cxx:693
 AliUEHist.cxx:694
 AliUEHist.cxx:695
 AliUEHist.cxx:696
 AliUEHist.cxx:697
 AliUEHist.cxx:698
 AliUEHist.cxx:699
 AliUEHist.cxx:700
 AliUEHist.cxx:701
 AliUEHist.cxx:702
 AliUEHist.cxx:703
 AliUEHist.cxx:704
 AliUEHist.cxx:705
 AliUEHist.cxx:706
 AliUEHist.cxx:707
 AliUEHist.cxx:708
 AliUEHist.cxx:709
 AliUEHist.cxx:710
 AliUEHist.cxx:711
 AliUEHist.cxx:712
 AliUEHist.cxx:713
 AliUEHist.cxx:714
 AliUEHist.cxx:715
 AliUEHist.cxx:716
 AliUEHist.cxx:717
 AliUEHist.cxx:718
 AliUEHist.cxx:719
 AliUEHist.cxx:720
 AliUEHist.cxx:721
 AliUEHist.cxx:722
 AliUEHist.cxx:723
 AliUEHist.cxx:724
 AliUEHist.cxx:725
 AliUEHist.cxx:726
 AliUEHist.cxx:727
 AliUEHist.cxx:728
 AliUEHist.cxx:729
 AliUEHist.cxx:730
 AliUEHist.cxx:731
 AliUEHist.cxx:732
 AliUEHist.cxx:733
 AliUEHist.cxx:734
 AliUEHist.cxx:735
 AliUEHist.cxx:736
 AliUEHist.cxx:737
 AliUEHist.cxx:738
 AliUEHist.cxx:739
 AliUEHist.cxx:740
 AliUEHist.cxx:741
 AliUEHist.cxx:742
 AliUEHist.cxx:743
 AliUEHist.cxx:744
 AliUEHist.cxx:745
 AliUEHist.cxx:746
 AliUEHist.cxx:747
 AliUEHist.cxx:748
 AliUEHist.cxx:749
 AliUEHist.cxx:750
 AliUEHist.cxx:751
 AliUEHist.cxx:752
 AliUEHist.cxx:753
 AliUEHist.cxx:754
 AliUEHist.cxx:755
 AliUEHist.cxx:756
 AliUEHist.cxx:757
 AliUEHist.cxx:758
 AliUEHist.cxx:759
 AliUEHist.cxx:760
 AliUEHist.cxx:761
 AliUEHist.cxx:762
 AliUEHist.cxx:763
 AliUEHist.cxx:764
 AliUEHist.cxx:765
 AliUEHist.cxx:766
 AliUEHist.cxx:767
 AliUEHist.cxx:768
 AliUEHist.cxx:769
 AliUEHist.cxx:770
 AliUEHist.cxx:771
 AliUEHist.cxx:772
 AliUEHist.cxx:773
 AliUEHist.cxx:774
 AliUEHist.cxx:775
 AliUEHist.cxx:776
 AliUEHist.cxx:777
 AliUEHist.cxx:778
 AliUEHist.cxx:779
 AliUEHist.cxx:780
 AliUEHist.cxx:781
 AliUEHist.cxx:782
 AliUEHist.cxx:783
 AliUEHist.cxx:784
 AliUEHist.cxx:785
 AliUEHist.cxx:786
 AliUEHist.cxx:787
 AliUEHist.cxx:788
 AliUEHist.cxx:789
 AliUEHist.cxx:790
 AliUEHist.cxx:791
 AliUEHist.cxx:792
 AliUEHist.cxx:793
 AliUEHist.cxx:794
 AliUEHist.cxx:795
 AliUEHist.cxx:796
 AliUEHist.cxx:797
 AliUEHist.cxx:798
 AliUEHist.cxx:799
 AliUEHist.cxx:800
 AliUEHist.cxx:801
 AliUEHist.cxx:802
 AliUEHist.cxx:803
 AliUEHist.cxx:804
 AliUEHist.cxx:805
 AliUEHist.cxx:806
 AliUEHist.cxx:807
 AliUEHist.cxx:808
 AliUEHist.cxx:809
 AliUEHist.cxx:810
 AliUEHist.cxx:811
 AliUEHist.cxx:812
 AliUEHist.cxx:813
 AliUEHist.cxx:814
 AliUEHist.cxx:815
 AliUEHist.cxx:816
 AliUEHist.cxx:817
 AliUEHist.cxx:818
 AliUEHist.cxx:819
 AliUEHist.cxx:820
 AliUEHist.cxx:821
 AliUEHist.cxx:822
 AliUEHist.cxx:823
 AliUEHist.cxx:824
 AliUEHist.cxx:825
 AliUEHist.cxx:826
 AliUEHist.cxx:827
 AliUEHist.cxx:828
 AliUEHist.cxx:829
 AliUEHist.cxx:830
 AliUEHist.cxx:831
 AliUEHist.cxx:832
 AliUEHist.cxx:833
 AliUEHist.cxx:834
 AliUEHist.cxx:835
 AliUEHist.cxx:836
 AliUEHist.cxx:837
 AliUEHist.cxx:838
 AliUEHist.cxx:839
 AliUEHist.cxx:840
 AliUEHist.cxx:841
 AliUEHist.cxx:842
 AliUEHist.cxx:843
 AliUEHist.cxx:844
 AliUEHist.cxx:845
 AliUEHist.cxx:846
 AliUEHist.cxx:847
 AliUEHist.cxx:848
 AliUEHist.cxx:849
 AliUEHist.cxx:850
 AliUEHist.cxx:851
 AliUEHist.cxx:852
 AliUEHist.cxx:853
 AliUEHist.cxx:854
 AliUEHist.cxx:855
 AliUEHist.cxx:856
 AliUEHist.cxx:857
 AliUEHist.cxx:858
 AliUEHist.cxx:859
 AliUEHist.cxx:860
 AliUEHist.cxx:861
 AliUEHist.cxx:862
 AliUEHist.cxx:863
 AliUEHist.cxx:864
 AliUEHist.cxx:865
 AliUEHist.cxx:866
 AliUEHist.cxx:867
 AliUEHist.cxx:868
 AliUEHist.cxx:869
 AliUEHist.cxx:870
 AliUEHist.cxx:871
 AliUEHist.cxx:872
 AliUEHist.cxx:873
 AliUEHist.cxx:874
 AliUEHist.cxx:875
 AliUEHist.cxx:876
 AliUEHist.cxx:877
 AliUEHist.cxx:878
 AliUEHist.cxx:879
 AliUEHist.cxx:880
 AliUEHist.cxx:881
 AliUEHist.cxx:882
 AliUEHist.cxx:883
 AliUEHist.cxx:884
 AliUEHist.cxx:885
 AliUEHist.cxx:886
 AliUEHist.cxx:887
 AliUEHist.cxx:888
 AliUEHist.cxx:889
 AliUEHist.cxx:890
 AliUEHist.cxx:891
 AliUEHist.cxx:892
 AliUEHist.cxx:893
 AliUEHist.cxx:894
 AliUEHist.cxx:895
 AliUEHist.cxx:896
 AliUEHist.cxx:897
 AliUEHist.cxx:898
 AliUEHist.cxx:899
 AliUEHist.cxx:900
 AliUEHist.cxx:901
 AliUEHist.cxx:902
 AliUEHist.cxx:903
 AliUEHist.cxx:904
 AliUEHist.cxx:905
 AliUEHist.cxx:906
 AliUEHist.cxx:907
 AliUEHist.cxx:908
 AliUEHist.cxx:909
 AliUEHist.cxx:910
 AliUEHist.cxx:911
 AliUEHist.cxx:912
 AliUEHist.cxx:913
 AliUEHist.cxx:914
 AliUEHist.cxx:915
 AliUEHist.cxx:916
 AliUEHist.cxx:917
 AliUEHist.cxx:918
 AliUEHist.cxx:919
 AliUEHist.cxx:920
 AliUEHist.cxx:921
 AliUEHist.cxx:922
 AliUEHist.cxx:923
 AliUEHist.cxx:924
 AliUEHist.cxx:925
 AliUEHist.cxx:926
 AliUEHist.cxx:927
 AliUEHist.cxx:928
 AliUEHist.cxx:929
 AliUEHist.cxx:930
 AliUEHist.cxx:931
 AliUEHist.cxx:932
 AliUEHist.cxx:933
 AliUEHist.cxx:934
 AliUEHist.cxx:935
 AliUEHist.cxx:936
 AliUEHist.cxx:937
 AliUEHist.cxx:938
 AliUEHist.cxx:939
 AliUEHist.cxx:940
 AliUEHist.cxx:941
 AliUEHist.cxx:942
 AliUEHist.cxx:943
 AliUEHist.cxx:944
 AliUEHist.cxx:945
 AliUEHist.cxx:946
 AliUEHist.cxx:947
 AliUEHist.cxx:948
 AliUEHist.cxx:949
 AliUEHist.cxx:950
 AliUEHist.cxx:951
 AliUEHist.cxx:952
 AliUEHist.cxx:953
 AliUEHist.cxx:954
 AliUEHist.cxx:955
 AliUEHist.cxx:956
 AliUEHist.cxx:957
 AliUEHist.cxx:958
 AliUEHist.cxx:959
 AliUEHist.cxx:960
 AliUEHist.cxx:961
 AliUEHist.cxx:962
 AliUEHist.cxx:963
 AliUEHist.cxx:964
 AliUEHist.cxx:965
 AliUEHist.cxx:966
 AliUEHist.cxx:967
 AliUEHist.cxx:968
 AliUEHist.cxx:969
 AliUEHist.cxx:970
 AliUEHist.cxx:971
 AliUEHist.cxx:972
 AliUEHist.cxx:973
 AliUEHist.cxx:974
 AliUEHist.cxx:975
 AliUEHist.cxx:976
 AliUEHist.cxx:977
 AliUEHist.cxx:978
 AliUEHist.cxx:979
 AliUEHist.cxx:980
 AliUEHist.cxx:981
 AliUEHist.cxx:982
 AliUEHist.cxx:983
 AliUEHist.cxx:984
 AliUEHist.cxx:985
 AliUEHist.cxx:986
 AliUEHist.cxx:987
 AliUEHist.cxx:988
 AliUEHist.cxx:989
 AliUEHist.cxx:990
 AliUEHist.cxx:991
 AliUEHist.cxx:992
 AliUEHist.cxx:993
 AliUEHist.cxx:994
 AliUEHist.cxx:995
 AliUEHist.cxx:996
 AliUEHist.cxx:997
 AliUEHist.cxx:998
 AliUEHist.cxx:999
 AliUEHist.cxx:1000
 AliUEHist.cxx:1001
 AliUEHist.cxx:1002
 AliUEHist.cxx:1003
 AliUEHist.cxx:1004
 AliUEHist.cxx:1005
 AliUEHist.cxx:1006
 AliUEHist.cxx:1007
 AliUEHist.cxx:1008
 AliUEHist.cxx:1009
 AliUEHist.cxx:1010
 AliUEHist.cxx:1011
 AliUEHist.cxx:1012
 AliUEHist.cxx:1013
 AliUEHist.cxx:1014
 AliUEHist.cxx:1015
 AliUEHist.cxx:1016
 AliUEHist.cxx:1017
 AliUEHist.cxx:1018
 AliUEHist.cxx:1019
 AliUEHist.cxx:1020
 AliUEHist.cxx:1021
 AliUEHist.cxx:1022
 AliUEHist.cxx:1023
 AliUEHist.cxx:1024
 AliUEHist.cxx:1025
 AliUEHist.cxx:1026
 AliUEHist.cxx:1027
 AliUEHist.cxx:1028
 AliUEHist.cxx:1029
 AliUEHist.cxx:1030
 AliUEHist.cxx:1031
 AliUEHist.cxx:1032
 AliUEHist.cxx:1033
 AliUEHist.cxx:1034
 AliUEHist.cxx:1035
 AliUEHist.cxx:1036
 AliUEHist.cxx:1037
 AliUEHist.cxx:1038
 AliUEHist.cxx:1039
 AliUEHist.cxx:1040
 AliUEHist.cxx:1041
 AliUEHist.cxx:1042
 AliUEHist.cxx:1043
 AliUEHist.cxx:1044
 AliUEHist.cxx:1045
 AliUEHist.cxx:1046
 AliUEHist.cxx:1047
 AliUEHist.cxx:1048
 AliUEHist.cxx:1049
 AliUEHist.cxx:1050
 AliUEHist.cxx:1051
 AliUEHist.cxx:1052
 AliUEHist.cxx:1053
 AliUEHist.cxx:1054
 AliUEHist.cxx:1055
 AliUEHist.cxx:1056
 AliUEHist.cxx:1057
 AliUEHist.cxx:1058
 AliUEHist.cxx:1059
 AliUEHist.cxx:1060
 AliUEHist.cxx:1061
 AliUEHist.cxx:1062
 AliUEHist.cxx:1063
 AliUEHist.cxx:1064
 AliUEHist.cxx:1065
 AliUEHist.cxx:1066
 AliUEHist.cxx:1067
 AliUEHist.cxx:1068
 AliUEHist.cxx:1069
 AliUEHist.cxx:1070
 AliUEHist.cxx:1071
 AliUEHist.cxx:1072
 AliUEHist.cxx:1073
 AliUEHist.cxx:1074
 AliUEHist.cxx:1075
 AliUEHist.cxx:1076
 AliUEHist.cxx:1077
 AliUEHist.cxx:1078
 AliUEHist.cxx:1079
 AliUEHist.cxx:1080
 AliUEHist.cxx:1081
 AliUEHist.cxx:1082
 AliUEHist.cxx:1083
 AliUEHist.cxx:1084
 AliUEHist.cxx:1085
 AliUEHist.cxx:1086
 AliUEHist.cxx:1087
 AliUEHist.cxx:1088
 AliUEHist.cxx:1089
 AliUEHist.cxx:1090
 AliUEHist.cxx:1091
 AliUEHist.cxx:1092
 AliUEHist.cxx:1093
 AliUEHist.cxx:1094
 AliUEHist.cxx:1095
 AliUEHist.cxx:1096
 AliUEHist.cxx:1097
 AliUEHist.cxx:1098
 AliUEHist.cxx:1099
 AliUEHist.cxx:1100
 AliUEHist.cxx:1101
 AliUEHist.cxx:1102
 AliUEHist.cxx:1103
 AliUEHist.cxx:1104
 AliUEHist.cxx:1105
 AliUEHist.cxx:1106
 AliUEHist.cxx:1107
 AliUEHist.cxx:1108
 AliUEHist.cxx:1109
 AliUEHist.cxx:1110
 AliUEHist.cxx:1111
 AliUEHist.cxx:1112
 AliUEHist.cxx:1113
 AliUEHist.cxx:1114
 AliUEHist.cxx:1115
 AliUEHist.cxx:1116
 AliUEHist.cxx:1117
 AliUEHist.cxx:1118
 AliUEHist.cxx:1119
 AliUEHist.cxx:1120
 AliUEHist.cxx:1121
 AliUEHist.cxx:1122
 AliUEHist.cxx:1123
 AliUEHist.cxx:1124
 AliUEHist.cxx:1125
 AliUEHist.cxx:1126
 AliUEHist.cxx:1127
 AliUEHist.cxx:1128
 AliUEHist.cxx:1129
 AliUEHist.cxx:1130
 AliUEHist.cxx:1131
 AliUEHist.cxx:1132
 AliUEHist.cxx:1133
 AliUEHist.cxx:1134
 AliUEHist.cxx:1135
 AliUEHist.cxx:1136
 AliUEHist.cxx:1137
 AliUEHist.cxx:1138
 AliUEHist.cxx:1139
 AliUEHist.cxx:1140
 AliUEHist.cxx:1141
 AliUEHist.cxx:1142
 AliUEHist.cxx:1143
 AliUEHist.cxx:1144
 AliUEHist.cxx:1145
 AliUEHist.cxx:1146
 AliUEHist.cxx:1147
 AliUEHist.cxx:1148
 AliUEHist.cxx:1149
 AliUEHist.cxx:1150
 AliUEHist.cxx:1151
 AliUEHist.cxx:1152
 AliUEHist.cxx:1153
 AliUEHist.cxx:1154
 AliUEHist.cxx:1155
 AliUEHist.cxx:1156
 AliUEHist.cxx:1157
 AliUEHist.cxx:1158
 AliUEHist.cxx:1159
 AliUEHist.cxx:1160
 AliUEHist.cxx:1161
 AliUEHist.cxx:1162
 AliUEHist.cxx:1163
 AliUEHist.cxx:1164
 AliUEHist.cxx:1165
 AliUEHist.cxx:1166
 AliUEHist.cxx:1167
 AliUEHist.cxx:1168
 AliUEHist.cxx:1169
 AliUEHist.cxx:1170
 AliUEHist.cxx:1171
 AliUEHist.cxx:1172
 AliUEHist.cxx:1173
 AliUEHist.cxx:1174
 AliUEHist.cxx:1175
 AliUEHist.cxx:1176
 AliUEHist.cxx:1177
 AliUEHist.cxx:1178
 AliUEHist.cxx:1179
 AliUEHist.cxx:1180
 AliUEHist.cxx:1181
 AliUEHist.cxx:1182
 AliUEHist.cxx:1183
 AliUEHist.cxx:1184
 AliUEHist.cxx:1185
 AliUEHist.cxx:1186
 AliUEHist.cxx:1187
 AliUEHist.cxx:1188
 AliUEHist.cxx:1189
 AliUEHist.cxx:1190
 AliUEHist.cxx:1191
 AliUEHist.cxx:1192
 AliUEHist.cxx:1193
 AliUEHist.cxx:1194
 AliUEHist.cxx:1195
 AliUEHist.cxx:1196
 AliUEHist.cxx:1197
 AliUEHist.cxx:1198
 AliUEHist.cxx:1199
 AliUEHist.cxx:1200
 AliUEHist.cxx:1201
 AliUEHist.cxx:1202
 AliUEHist.cxx:1203
 AliUEHist.cxx:1204
 AliUEHist.cxx:1205
 AliUEHist.cxx:1206
 AliUEHist.cxx:1207
 AliUEHist.cxx:1208
 AliUEHist.cxx:1209
 AliUEHist.cxx:1210
 AliUEHist.cxx:1211
 AliUEHist.cxx:1212
 AliUEHist.cxx:1213
 AliUEHist.cxx:1214
 AliUEHist.cxx:1215
 AliUEHist.cxx:1216
 AliUEHist.cxx:1217
 AliUEHist.cxx:1218
 AliUEHist.cxx:1219
 AliUEHist.cxx:1220
 AliUEHist.cxx:1221
 AliUEHist.cxx:1222
 AliUEHist.cxx:1223
 AliUEHist.cxx:1224
 AliUEHist.cxx:1225
 AliUEHist.cxx:1226
 AliUEHist.cxx:1227
 AliUEHist.cxx:1228
 AliUEHist.cxx:1229
 AliUEHist.cxx:1230
 AliUEHist.cxx:1231
 AliUEHist.cxx:1232
 AliUEHist.cxx:1233
 AliUEHist.cxx:1234
 AliUEHist.cxx:1235
 AliUEHist.cxx:1236
 AliUEHist.cxx:1237
 AliUEHist.cxx:1238
 AliUEHist.cxx:1239
 AliUEHist.cxx:1240
 AliUEHist.cxx:1241
 AliUEHist.cxx:1242
 AliUEHist.cxx:1243
 AliUEHist.cxx:1244
 AliUEHist.cxx:1245
 AliUEHist.cxx:1246
 AliUEHist.cxx:1247
 AliUEHist.cxx:1248
 AliUEHist.cxx:1249
 AliUEHist.cxx:1250
 AliUEHist.cxx:1251
 AliUEHist.cxx:1252
 AliUEHist.cxx:1253
 AliUEHist.cxx:1254
 AliUEHist.cxx:1255
 AliUEHist.cxx:1256
 AliUEHist.cxx:1257
 AliUEHist.cxx:1258
 AliUEHist.cxx:1259
 AliUEHist.cxx:1260
 AliUEHist.cxx:1261
 AliUEHist.cxx:1262
 AliUEHist.cxx:1263
 AliUEHist.cxx:1264
 AliUEHist.cxx:1265
 AliUEHist.cxx:1266
 AliUEHist.cxx:1267
 AliUEHist.cxx:1268
 AliUEHist.cxx:1269
 AliUEHist.cxx:1270
 AliUEHist.cxx:1271
 AliUEHist.cxx:1272
 AliUEHist.cxx:1273
 AliUEHist.cxx:1274
 AliUEHist.cxx:1275
 AliUEHist.cxx:1276
 AliUEHist.cxx:1277
 AliUEHist.cxx:1278
 AliUEHist.cxx:1279
 AliUEHist.cxx:1280
 AliUEHist.cxx:1281
 AliUEHist.cxx:1282
 AliUEHist.cxx:1283
 AliUEHist.cxx:1284
 AliUEHist.cxx:1285
 AliUEHist.cxx:1286
 AliUEHist.cxx:1287
 AliUEHist.cxx:1288
 AliUEHist.cxx:1289
 AliUEHist.cxx:1290
 AliUEHist.cxx:1291
 AliUEHist.cxx:1292
 AliUEHist.cxx:1293
 AliUEHist.cxx:1294
 AliUEHist.cxx:1295
 AliUEHist.cxx:1296
 AliUEHist.cxx:1297
 AliUEHist.cxx:1298
 AliUEHist.cxx:1299
 AliUEHist.cxx:1300
 AliUEHist.cxx:1301
 AliUEHist.cxx:1302
 AliUEHist.cxx:1303
 AliUEHist.cxx:1304
 AliUEHist.cxx:1305
 AliUEHist.cxx:1306
 AliUEHist.cxx:1307
 AliUEHist.cxx:1308
 AliUEHist.cxx:1309
 AliUEHist.cxx:1310
 AliUEHist.cxx:1311
 AliUEHist.cxx:1312
 AliUEHist.cxx:1313
 AliUEHist.cxx:1314
 AliUEHist.cxx:1315
 AliUEHist.cxx:1316
 AliUEHist.cxx:1317
 AliUEHist.cxx:1318
 AliUEHist.cxx:1319
 AliUEHist.cxx:1320
 AliUEHist.cxx:1321
 AliUEHist.cxx:1322
 AliUEHist.cxx:1323
 AliUEHist.cxx:1324
 AliUEHist.cxx:1325
 AliUEHist.cxx:1326
 AliUEHist.cxx:1327
 AliUEHist.cxx:1328
 AliUEHist.cxx:1329
 AliUEHist.cxx:1330
 AliUEHist.cxx:1331
 AliUEHist.cxx:1332
 AliUEHist.cxx:1333
 AliUEHist.cxx:1334
 AliUEHist.cxx:1335
 AliUEHist.cxx:1336
 AliUEHist.cxx:1337
 AliUEHist.cxx:1338
 AliUEHist.cxx:1339
 AliUEHist.cxx:1340
 AliUEHist.cxx:1341
 AliUEHist.cxx:1342
 AliUEHist.cxx:1343
 AliUEHist.cxx:1344
 AliUEHist.cxx:1345
 AliUEHist.cxx:1346
 AliUEHist.cxx:1347
 AliUEHist.cxx:1348
 AliUEHist.cxx:1349
 AliUEHist.cxx:1350
 AliUEHist.cxx:1351
 AliUEHist.cxx:1352
 AliUEHist.cxx:1353
 AliUEHist.cxx:1354
 AliUEHist.cxx:1355
 AliUEHist.cxx:1356
 AliUEHist.cxx:1357
 AliUEHist.cxx:1358
 AliUEHist.cxx:1359
 AliUEHist.cxx:1360
 AliUEHist.cxx:1361
 AliUEHist.cxx:1362
 AliUEHist.cxx:1363
 AliUEHist.cxx:1364
 AliUEHist.cxx:1365
 AliUEHist.cxx:1366
 AliUEHist.cxx:1367
 AliUEHist.cxx:1368
 AliUEHist.cxx:1369
 AliUEHist.cxx:1370
 AliUEHist.cxx:1371
 AliUEHist.cxx:1372
 AliUEHist.cxx:1373
 AliUEHist.cxx:1374
 AliUEHist.cxx:1375
 AliUEHist.cxx:1376
 AliUEHist.cxx:1377
 AliUEHist.cxx:1378
 AliUEHist.cxx:1379
 AliUEHist.cxx:1380
 AliUEHist.cxx:1381
 AliUEHist.cxx:1382
 AliUEHist.cxx:1383
 AliUEHist.cxx:1384
 AliUEHist.cxx:1385
 AliUEHist.cxx:1386
 AliUEHist.cxx:1387
 AliUEHist.cxx:1388
 AliUEHist.cxx:1389
 AliUEHist.cxx:1390
 AliUEHist.cxx:1391
 AliUEHist.cxx:1392
 AliUEHist.cxx:1393
 AliUEHist.cxx:1394
 AliUEHist.cxx:1395
 AliUEHist.cxx:1396
 AliUEHist.cxx:1397
 AliUEHist.cxx:1398
 AliUEHist.cxx:1399
 AliUEHist.cxx:1400
 AliUEHist.cxx:1401
 AliUEHist.cxx:1402
 AliUEHist.cxx:1403
 AliUEHist.cxx:1404
 AliUEHist.cxx:1405
 AliUEHist.cxx:1406
 AliUEHist.cxx:1407
 AliUEHist.cxx:1408
 AliUEHist.cxx:1409
 AliUEHist.cxx:1410
 AliUEHist.cxx:1411
 AliUEHist.cxx:1412
 AliUEHist.cxx:1413
 AliUEHist.cxx:1414
 AliUEHist.cxx:1415
 AliUEHist.cxx:1416
 AliUEHist.cxx:1417
 AliUEHist.cxx:1418
 AliUEHist.cxx:1419
 AliUEHist.cxx:1420
 AliUEHist.cxx:1421
 AliUEHist.cxx:1422
 AliUEHist.cxx:1423
 AliUEHist.cxx:1424
 AliUEHist.cxx:1425
 AliUEHist.cxx:1426
 AliUEHist.cxx:1427
 AliUEHist.cxx:1428
 AliUEHist.cxx:1429
 AliUEHist.cxx:1430
 AliUEHist.cxx:1431
 AliUEHist.cxx:1432
 AliUEHist.cxx:1433
 AliUEHist.cxx:1434
 AliUEHist.cxx:1435
 AliUEHist.cxx:1436
 AliUEHist.cxx:1437
 AliUEHist.cxx:1438
 AliUEHist.cxx:1439
 AliUEHist.cxx:1440
 AliUEHist.cxx:1441
 AliUEHist.cxx:1442
 AliUEHist.cxx:1443
 AliUEHist.cxx:1444
 AliUEHist.cxx:1445
 AliUEHist.cxx:1446
 AliUEHist.cxx:1447
 AliUEHist.cxx:1448
 AliUEHist.cxx:1449
 AliUEHist.cxx:1450
 AliUEHist.cxx:1451
 AliUEHist.cxx:1452
 AliUEHist.cxx:1453
 AliUEHist.cxx:1454
 AliUEHist.cxx:1455
 AliUEHist.cxx:1456
 AliUEHist.cxx:1457
 AliUEHist.cxx:1458
 AliUEHist.cxx:1459
 AliUEHist.cxx:1460
 AliUEHist.cxx:1461
 AliUEHist.cxx:1462
 AliUEHist.cxx:1463
 AliUEHist.cxx:1464
 AliUEHist.cxx:1465
 AliUEHist.cxx:1466
 AliUEHist.cxx:1467
 AliUEHist.cxx:1468
 AliUEHist.cxx:1469
 AliUEHist.cxx:1470
 AliUEHist.cxx:1471
 AliUEHist.cxx:1472
 AliUEHist.cxx:1473
 AliUEHist.cxx:1474
 AliUEHist.cxx:1475
 AliUEHist.cxx:1476
 AliUEHist.cxx:1477
 AliUEHist.cxx:1478
 AliUEHist.cxx:1479
 AliUEHist.cxx:1480
 AliUEHist.cxx:1481
 AliUEHist.cxx:1482
 AliUEHist.cxx:1483
 AliUEHist.cxx:1484
 AliUEHist.cxx:1485
 AliUEHist.cxx:1486
 AliUEHist.cxx:1487
 AliUEHist.cxx:1488
 AliUEHist.cxx:1489
 AliUEHist.cxx:1490
 AliUEHist.cxx:1491
 AliUEHist.cxx:1492
 AliUEHist.cxx:1493
 AliUEHist.cxx:1494
 AliUEHist.cxx:1495
 AliUEHist.cxx:1496
 AliUEHist.cxx:1497
 AliUEHist.cxx:1498
 AliUEHist.cxx:1499
 AliUEHist.cxx:1500
 AliUEHist.cxx:1501
 AliUEHist.cxx:1502
 AliUEHist.cxx:1503
 AliUEHist.cxx:1504
 AliUEHist.cxx:1505
 AliUEHist.cxx:1506
 AliUEHist.cxx:1507
 AliUEHist.cxx:1508
 AliUEHist.cxx:1509
 AliUEHist.cxx:1510
 AliUEHist.cxx:1511
 AliUEHist.cxx:1512
 AliUEHist.cxx:1513
 AliUEHist.cxx:1514
 AliUEHist.cxx:1515
 AliUEHist.cxx:1516
 AliUEHist.cxx:1517
 AliUEHist.cxx:1518
 AliUEHist.cxx:1519
 AliUEHist.cxx:1520
 AliUEHist.cxx:1521
 AliUEHist.cxx:1522
 AliUEHist.cxx:1523
 AliUEHist.cxx:1524
 AliUEHist.cxx:1525
 AliUEHist.cxx:1526
 AliUEHist.cxx:1527
 AliUEHist.cxx:1528
 AliUEHist.cxx:1529
 AliUEHist.cxx:1530
 AliUEHist.cxx:1531
 AliUEHist.cxx:1532
 AliUEHist.cxx:1533
 AliUEHist.cxx:1534
 AliUEHist.cxx:1535
 AliUEHist.cxx:1536
 AliUEHist.cxx:1537
 AliUEHist.cxx:1538
 AliUEHist.cxx:1539
 AliUEHist.cxx:1540
 AliUEHist.cxx:1541
 AliUEHist.cxx:1542
 AliUEHist.cxx:1543
 AliUEHist.cxx:1544
 AliUEHist.cxx:1545
 AliUEHist.cxx:1546
 AliUEHist.cxx:1547
 AliUEHist.cxx:1548
 AliUEHist.cxx:1549
 AliUEHist.cxx:1550
 AliUEHist.cxx:1551
 AliUEHist.cxx:1552
 AliUEHist.cxx:1553
 AliUEHist.cxx:1554
 AliUEHist.cxx:1555
 AliUEHist.cxx:1556
 AliUEHist.cxx:1557
 AliUEHist.cxx:1558
 AliUEHist.cxx:1559
 AliUEHist.cxx:1560
 AliUEHist.cxx:1561
 AliUEHist.cxx:1562
 AliUEHist.cxx:1563
 AliUEHist.cxx:1564
 AliUEHist.cxx:1565
 AliUEHist.cxx:1566
 AliUEHist.cxx:1567
 AliUEHist.cxx:1568
 AliUEHist.cxx:1569
 AliUEHist.cxx:1570
 AliUEHist.cxx:1571
 AliUEHist.cxx:1572
 AliUEHist.cxx:1573
 AliUEHist.cxx:1574
 AliUEHist.cxx:1575
 AliUEHist.cxx:1576
 AliUEHist.cxx:1577
 AliUEHist.cxx:1578
 AliUEHist.cxx:1579
 AliUEHist.cxx:1580
 AliUEHist.cxx:1581
 AliUEHist.cxx:1582
 AliUEHist.cxx:1583
 AliUEHist.cxx:1584
 AliUEHist.cxx:1585
 AliUEHist.cxx:1586
 AliUEHist.cxx:1587
 AliUEHist.cxx:1588
 AliUEHist.cxx:1589
 AliUEHist.cxx:1590
 AliUEHist.cxx:1591
 AliUEHist.cxx:1592
 AliUEHist.cxx:1593
 AliUEHist.cxx:1594
 AliUEHist.cxx:1595
 AliUEHist.cxx:1596
 AliUEHist.cxx:1597
 AliUEHist.cxx:1598
 AliUEHist.cxx:1599
 AliUEHist.cxx:1600
 AliUEHist.cxx:1601
 AliUEHist.cxx:1602
 AliUEHist.cxx:1603
 AliUEHist.cxx:1604
 AliUEHist.cxx:1605
 AliUEHist.cxx:1606
 AliUEHist.cxx:1607
 AliUEHist.cxx:1608
 AliUEHist.cxx:1609
 AliUEHist.cxx:1610
 AliUEHist.cxx:1611
 AliUEHist.cxx:1612
 AliUEHist.cxx:1613
 AliUEHist.cxx:1614
 AliUEHist.cxx:1615
 AliUEHist.cxx:1616
 AliUEHist.cxx:1617
 AliUEHist.cxx:1618
 AliUEHist.cxx:1619
 AliUEHist.cxx:1620
 AliUEHist.cxx:1621
 AliUEHist.cxx:1622
 AliUEHist.cxx:1623
 AliUEHist.cxx:1624
 AliUEHist.cxx:1625
 AliUEHist.cxx:1626
 AliUEHist.cxx:1627
 AliUEHist.cxx:1628
 AliUEHist.cxx:1629
 AliUEHist.cxx:1630
 AliUEHist.cxx:1631
 AliUEHist.cxx:1632
 AliUEHist.cxx:1633
 AliUEHist.cxx:1634
 AliUEHist.cxx:1635
 AliUEHist.cxx:1636
 AliUEHist.cxx:1637
 AliUEHist.cxx:1638
 AliUEHist.cxx:1639
 AliUEHist.cxx:1640
 AliUEHist.cxx:1641
 AliUEHist.cxx:1642
 AliUEHist.cxx:1643
 AliUEHist.cxx:1644
 AliUEHist.cxx:1645
 AliUEHist.cxx:1646
 AliUEHist.cxx:1647
 AliUEHist.cxx:1648
 AliUEHist.cxx:1649
 AliUEHist.cxx:1650
 AliUEHist.cxx:1651
 AliUEHist.cxx:1652
 AliUEHist.cxx:1653
 AliUEHist.cxx:1654
 AliUEHist.cxx:1655
 AliUEHist.cxx:1656
 AliUEHist.cxx:1657
 AliUEHist.cxx:1658
 AliUEHist.cxx:1659
 AliUEHist.cxx:1660
 AliUEHist.cxx:1661
 AliUEHist.cxx:1662
 AliUEHist.cxx:1663
 AliUEHist.cxx:1664
 AliUEHist.cxx:1665
 AliUEHist.cxx:1666
 AliUEHist.cxx:1667
 AliUEHist.cxx:1668
 AliUEHist.cxx:1669
 AliUEHist.cxx:1670
 AliUEHist.cxx:1671
 AliUEHist.cxx:1672
 AliUEHist.cxx:1673
 AliUEHist.cxx:1674
 AliUEHist.cxx:1675
 AliUEHist.cxx:1676
 AliUEHist.cxx:1677
 AliUEHist.cxx:1678
 AliUEHist.cxx:1679
 AliUEHist.cxx:1680
 AliUEHist.cxx:1681
 AliUEHist.cxx:1682
 AliUEHist.cxx:1683
 AliUEHist.cxx:1684
 AliUEHist.cxx:1685
 AliUEHist.cxx:1686
 AliUEHist.cxx:1687
 AliUEHist.cxx:1688
 AliUEHist.cxx:1689
 AliUEHist.cxx:1690
 AliUEHist.cxx:1691
 AliUEHist.cxx:1692
 AliUEHist.cxx:1693
 AliUEHist.cxx:1694
 AliUEHist.cxx:1695
 AliUEHist.cxx:1696
 AliUEHist.cxx:1697
 AliUEHist.cxx:1698
 AliUEHist.cxx:1699
 AliUEHist.cxx:1700
 AliUEHist.cxx:1701
 AliUEHist.cxx:1702
 AliUEHist.cxx:1703
 AliUEHist.cxx:1704
 AliUEHist.cxx:1705
 AliUEHist.cxx:1706
 AliUEHist.cxx:1707
 AliUEHist.cxx:1708
 AliUEHist.cxx:1709
 AliUEHist.cxx:1710
 AliUEHist.cxx:1711
 AliUEHist.cxx:1712
 AliUEHist.cxx:1713
 AliUEHist.cxx:1714
 AliUEHist.cxx:1715
 AliUEHist.cxx:1716
 AliUEHist.cxx:1717
 AliUEHist.cxx:1718
 AliUEHist.cxx:1719
 AliUEHist.cxx:1720
 AliUEHist.cxx:1721
 AliUEHist.cxx:1722
 AliUEHist.cxx:1723
 AliUEHist.cxx:1724
 AliUEHist.cxx:1725
 AliUEHist.cxx:1726
 AliUEHist.cxx:1727
 AliUEHist.cxx:1728
 AliUEHist.cxx:1729
 AliUEHist.cxx:1730
 AliUEHist.cxx:1731
 AliUEHist.cxx:1732
 AliUEHist.cxx:1733
 AliUEHist.cxx:1734
 AliUEHist.cxx:1735
 AliUEHist.cxx:1736
 AliUEHist.cxx:1737
 AliUEHist.cxx:1738
 AliUEHist.cxx:1739
 AliUEHist.cxx:1740
 AliUEHist.cxx:1741
 AliUEHist.cxx:1742
 AliUEHist.cxx:1743
 AliUEHist.cxx:1744
 AliUEHist.cxx:1745
 AliUEHist.cxx:1746
 AliUEHist.cxx:1747
 AliUEHist.cxx:1748
 AliUEHist.cxx:1749
 AliUEHist.cxx:1750
 AliUEHist.cxx:1751
 AliUEHist.cxx:1752
 AliUEHist.cxx:1753
 AliUEHist.cxx:1754
 AliUEHist.cxx:1755
 AliUEHist.cxx:1756
 AliUEHist.cxx:1757
 AliUEHist.cxx:1758
 AliUEHist.cxx:1759
 AliUEHist.cxx:1760
 AliUEHist.cxx:1761
 AliUEHist.cxx:1762
 AliUEHist.cxx:1763
 AliUEHist.cxx:1764
 AliUEHist.cxx:1765
 AliUEHist.cxx:1766
 AliUEHist.cxx:1767
 AliUEHist.cxx:1768
 AliUEHist.cxx:1769
 AliUEHist.cxx:1770
 AliUEHist.cxx:1771
 AliUEHist.cxx:1772
 AliUEHist.cxx:1773
 AliUEHist.cxx:1774
 AliUEHist.cxx:1775
 AliUEHist.cxx:1776
 AliUEHist.cxx:1777
 AliUEHist.cxx:1778
 AliUEHist.cxx:1779
 AliUEHist.cxx:1780
 AliUEHist.cxx:1781
 AliUEHist.cxx:1782
 AliUEHist.cxx:1783
 AliUEHist.cxx:1784
 AliUEHist.cxx:1785
 AliUEHist.cxx:1786
 AliUEHist.cxx:1787
 AliUEHist.cxx:1788
 AliUEHist.cxx:1789
 AliUEHist.cxx:1790
 AliUEHist.cxx:1791
 AliUEHist.cxx:1792
 AliUEHist.cxx:1793
 AliUEHist.cxx:1794
 AliUEHist.cxx:1795
 AliUEHist.cxx:1796
 AliUEHist.cxx:1797
 AliUEHist.cxx:1798
 AliUEHist.cxx:1799
 AliUEHist.cxx:1800
 AliUEHist.cxx:1801
 AliUEHist.cxx:1802
 AliUEHist.cxx:1803
 AliUEHist.cxx:1804
 AliUEHist.cxx:1805
 AliUEHist.cxx:1806
 AliUEHist.cxx:1807
 AliUEHist.cxx:1808
 AliUEHist.cxx:1809
 AliUEHist.cxx:1810
 AliUEHist.cxx:1811
 AliUEHist.cxx:1812
 AliUEHist.cxx:1813
 AliUEHist.cxx:1814
 AliUEHist.cxx:1815
 AliUEHist.cxx:1816
 AliUEHist.cxx:1817
 AliUEHist.cxx:1818
 AliUEHist.cxx:1819
 AliUEHist.cxx:1820
 AliUEHist.cxx:1821
 AliUEHist.cxx:1822
 AliUEHist.cxx:1823
 AliUEHist.cxx:1824
 AliUEHist.cxx:1825
 AliUEHist.cxx:1826
 AliUEHist.cxx:1827
 AliUEHist.cxx:1828
 AliUEHist.cxx:1829
 AliUEHist.cxx:1830
 AliUEHist.cxx:1831
 AliUEHist.cxx:1832
 AliUEHist.cxx:1833
 AliUEHist.cxx:1834
 AliUEHist.cxx:1835
 AliUEHist.cxx:1836
 AliUEHist.cxx:1837
 AliUEHist.cxx:1838
 AliUEHist.cxx:1839
 AliUEHist.cxx:1840
 AliUEHist.cxx:1841
 AliUEHist.cxx:1842
 AliUEHist.cxx:1843
 AliUEHist.cxx:1844
 AliUEHist.cxx:1845
 AliUEHist.cxx:1846
 AliUEHist.cxx:1847
 AliUEHist.cxx:1848
 AliUEHist.cxx:1849
 AliUEHist.cxx:1850
 AliUEHist.cxx:1851
 AliUEHist.cxx:1852
 AliUEHist.cxx:1853
 AliUEHist.cxx:1854
 AliUEHist.cxx:1855
 AliUEHist.cxx:1856
 AliUEHist.cxx:1857
 AliUEHist.cxx:1858
 AliUEHist.cxx:1859
 AliUEHist.cxx:1860
 AliUEHist.cxx:1861
 AliUEHist.cxx:1862
 AliUEHist.cxx:1863
 AliUEHist.cxx:1864
 AliUEHist.cxx:1865
 AliUEHist.cxx:1866
 AliUEHist.cxx:1867
 AliUEHist.cxx:1868
 AliUEHist.cxx:1869
 AliUEHist.cxx:1870
 AliUEHist.cxx:1871
 AliUEHist.cxx:1872
 AliUEHist.cxx:1873
 AliUEHist.cxx:1874
 AliUEHist.cxx:1875
 AliUEHist.cxx:1876
 AliUEHist.cxx:1877
 AliUEHist.cxx:1878
 AliUEHist.cxx:1879
 AliUEHist.cxx:1880
 AliUEHist.cxx:1881
 AliUEHist.cxx:1882
 AliUEHist.cxx:1883
 AliUEHist.cxx:1884
 AliUEHist.cxx:1885
 AliUEHist.cxx:1886
 AliUEHist.cxx:1887
 AliUEHist.cxx:1888
 AliUEHist.cxx:1889
 AliUEHist.cxx:1890
 AliUEHist.cxx:1891
 AliUEHist.cxx:1892
 AliUEHist.cxx:1893
 AliUEHist.cxx:1894
 AliUEHist.cxx:1895
 AliUEHist.cxx:1896
 AliUEHist.cxx:1897
 AliUEHist.cxx:1898
 AliUEHist.cxx:1899
 AliUEHist.cxx:1900
 AliUEHist.cxx:1901
 AliUEHist.cxx:1902
 AliUEHist.cxx:1903
 AliUEHist.cxx:1904
 AliUEHist.cxx:1905
 AliUEHist.cxx:1906
 AliUEHist.cxx:1907
 AliUEHist.cxx:1908
 AliUEHist.cxx:1909
 AliUEHist.cxx:1910
 AliUEHist.cxx:1911
 AliUEHist.cxx:1912
 AliUEHist.cxx:1913
 AliUEHist.cxx:1914
 AliUEHist.cxx:1915
 AliUEHist.cxx:1916
 AliUEHist.cxx:1917
 AliUEHist.cxx:1918
 AliUEHist.cxx:1919
 AliUEHist.cxx:1920
 AliUEHist.cxx:1921
 AliUEHist.cxx:1922
 AliUEHist.cxx:1923
 AliUEHist.cxx:1924
 AliUEHist.cxx:1925
 AliUEHist.cxx:1926
 AliUEHist.cxx:1927
 AliUEHist.cxx:1928
 AliUEHist.cxx:1929
 AliUEHist.cxx:1930
 AliUEHist.cxx:1931
 AliUEHist.cxx:1932
 AliUEHist.cxx:1933
 AliUEHist.cxx:1934
 AliUEHist.cxx:1935
 AliUEHist.cxx:1936
 AliUEHist.cxx:1937
 AliUEHist.cxx:1938
 AliUEHist.cxx:1939
 AliUEHist.cxx:1940
 AliUEHist.cxx:1941
 AliUEHist.cxx:1942
 AliUEHist.cxx:1943
 AliUEHist.cxx:1944
 AliUEHist.cxx:1945
 AliUEHist.cxx:1946
 AliUEHist.cxx:1947
 AliUEHist.cxx:1948
 AliUEHist.cxx:1949
 AliUEHist.cxx:1950
 AliUEHist.cxx:1951
 AliUEHist.cxx:1952
 AliUEHist.cxx:1953
 AliUEHist.cxx:1954
 AliUEHist.cxx:1955
 AliUEHist.cxx:1956
 AliUEHist.cxx:1957
 AliUEHist.cxx:1958
 AliUEHist.cxx:1959
 AliUEHist.cxx:1960
 AliUEHist.cxx:1961
 AliUEHist.cxx:1962
 AliUEHist.cxx:1963
 AliUEHist.cxx:1964
 AliUEHist.cxx:1965
 AliUEHist.cxx:1966
 AliUEHist.cxx:1967
 AliUEHist.cxx:1968
 AliUEHist.cxx:1969
 AliUEHist.cxx:1970
 AliUEHist.cxx:1971
 AliUEHist.cxx:1972
 AliUEHist.cxx:1973
 AliUEHist.cxx:1974
 AliUEHist.cxx:1975
 AliUEHist.cxx:1976
 AliUEHist.cxx:1977
 AliUEHist.cxx:1978
 AliUEHist.cxx:1979
 AliUEHist.cxx:1980
 AliUEHist.cxx:1981
 AliUEHist.cxx:1982
 AliUEHist.cxx:1983
 AliUEHist.cxx:1984
 AliUEHist.cxx:1985
 AliUEHist.cxx:1986
 AliUEHist.cxx:1987
 AliUEHist.cxx:1988
 AliUEHist.cxx:1989
 AliUEHist.cxx:1990
 AliUEHist.cxx:1991
 AliUEHist.cxx:1992
 AliUEHist.cxx:1993
 AliUEHist.cxx:1994
 AliUEHist.cxx:1995
 AliUEHist.cxx:1996
 AliUEHist.cxx:1997
 AliUEHist.cxx:1998
 AliUEHist.cxx:1999
 AliUEHist.cxx:2000
 AliUEHist.cxx:2001
 AliUEHist.cxx:2002
 AliUEHist.cxx:2003
 AliUEHist.cxx:2004
 AliUEHist.cxx:2005
 AliUEHist.cxx:2006
 AliUEHist.cxx:2007
 AliUEHist.cxx:2008
 AliUEHist.cxx:2009
 AliUEHist.cxx:2010
 AliUEHist.cxx:2011
 AliUEHist.cxx:2012
 AliUEHist.cxx:2013
 AliUEHist.cxx:2014
 AliUEHist.cxx:2015
 AliUEHist.cxx:2016
 AliUEHist.cxx:2017
 AliUEHist.cxx:2018
 AliUEHist.cxx:2019
 AliUEHist.cxx:2020
 AliUEHist.cxx:2021
 AliUEHist.cxx:2022
 AliUEHist.cxx:2023
 AliUEHist.cxx:2024
 AliUEHist.cxx:2025
 AliUEHist.cxx:2026
 AliUEHist.cxx:2027
 AliUEHist.cxx:2028
 AliUEHist.cxx:2029
 AliUEHist.cxx:2030
 AliUEHist.cxx:2031
 AliUEHist.cxx:2032
 AliUEHist.cxx:2033
 AliUEHist.cxx:2034
 AliUEHist.cxx:2035
 AliUEHist.cxx:2036
 AliUEHist.cxx:2037
 AliUEHist.cxx:2038
 AliUEHist.cxx:2039
 AliUEHist.cxx:2040
 AliUEHist.cxx:2041
 AliUEHist.cxx:2042
 AliUEHist.cxx:2043
 AliUEHist.cxx:2044
 AliUEHist.cxx:2045
 AliUEHist.cxx:2046
 AliUEHist.cxx:2047
 AliUEHist.cxx:2048
 AliUEHist.cxx:2049
 AliUEHist.cxx:2050
 AliUEHist.cxx:2051
 AliUEHist.cxx:2052
 AliUEHist.cxx:2053
 AliUEHist.cxx:2054
 AliUEHist.cxx:2055
 AliUEHist.cxx:2056
 AliUEHist.cxx:2057
 AliUEHist.cxx:2058
 AliUEHist.cxx:2059
 AliUEHist.cxx:2060
 AliUEHist.cxx:2061
 AliUEHist.cxx:2062
 AliUEHist.cxx:2063
 AliUEHist.cxx:2064
 AliUEHist.cxx:2065
 AliUEHist.cxx:2066
 AliUEHist.cxx:2067
 AliUEHist.cxx:2068
 AliUEHist.cxx:2069
 AliUEHist.cxx:2070
 AliUEHist.cxx:2071
 AliUEHist.cxx:2072
 AliUEHist.cxx:2073
 AliUEHist.cxx:2074
 AliUEHist.cxx:2075
 AliUEHist.cxx:2076
 AliUEHist.cxx:2077
 AliUEHist.cxx:2078
 AliUEHist.cxx:2079
 AliUEHist.cxx:2080
 AliUEHist.cxx:2081
 AliUEHist.cxx:2082
 AliUEHist.cxx:2083
 AliUEHist.cxx:2084
 AliUEHist.cxx:2085
 AliUEHist.cxx:2086
 AliUEHist.cxx:2087
 AliUEHist.cxx:2088
 AliUEHist.cxx:2089
 AliUEHist.cxx:2090
 AliUEHist.cxx:2091
 AliUEHist.cxx:2092
 AliUEHist.cxx:2093
 AliUEHist.cxx:2094
 AliUEHist.cxx:2095
 AliUEHist.cxx:2096
 AliUEHist.cxx:2097
 AliUEHist.cxx:2098
 AliUEHist.cxx:2099
 AliUEHist.cxx:2100
 AliUEHist.cxx:2101
 AliUEHist.cxx:2102
 AliUEHist.cxx:2103
 AliUEHist.cxx:2104
 AliUEHist.cxx:2105
 AliUEHist.cxx:2106
 AliUEHist.cxx:2107
 AliUEHist.cxx:2108
 AliUEHist.cxx:2109
 AliUEHist.cxx:2110
 AliUEHist.cxx:2111
 AliUEHist.cxx:2112
 AliUEHist.cxx:2113
 AliUEHist.cxx:2114
 AliUEHist.cxx:2115
 AliUEHist.cxx:2116
 AliUEHist.cxx:2117
 AliUEHist.cxx:2118
 AliUEHist.cxx:2119
 AliUEHist.cxx:2120
 AliUEHist.cxx:2121
 AliUEHist.cxx:2122
 AliUEHist.cxx:2123
 AliUEHist.cxx:2124
 AliUEHist.cxx:2125
 AliUEHist.cxx:2126
 AliUEHist.cxx:2127
 AliUEHist.cxx:2128
 AliUEHist.cxx:2129
 AliUEHist.cxx:2130
 AliUEHist.cxx:2131
 AliUEHist.cxx:2132
 AliUEHist.cxx:2133
 AliUEHist.cxx:2134
 AliUEHist.cxx:2135
 AliUEHist.cxx:2136
 AliUEHist.cxx:2137
 AliUEHist.cxx:2138
 AliUEHist.cxx:2139
 AliUEHist.cxx:2140
 AliUEHist.cxx:2141
 AliUEHist.cxx:2142
 AliUEHist.cxx:2143
 AliUEHist.cxx:2144
 AliUEHist.cxx:2145
 AliUEHist.cxx:2146
 AliUEHist.cxx:2147
 AliUEHist.cxx:2148
 AliUEHist.cxx:2149
 AliUEHist.cxx:2150
 AliUEHist.cxx:2151
 AliUEHist.cxx:2152
 AliUEHist.cxx:2153
 AliUEHist.cxx:2154
 AliUEHist.cxx:2155
 AliUEHist.cxx:2156
 AliUEHist.cxx:2157
 AliUEHist.cxx:2158
 AliUEHist.cxx:2159
 AliUEHist.cxx:2160
 AliUEHist.cxx:2161
 AliUEHist.cxx:2162
 AliUEHist.cxx:2163
 AliUEHist.cxx:2164
 AliUEHist.cxx:2165
 AliUEHist.cxx:2166
 AliUEHist.cxx:2167
 AliUEHist.cxx:2168
 AliUEHist.cxx:2169
 AliUEHist.cxx:2170
 AliUEHist.cxx:2171
 AliUEHist.cxx:2172
 AliUEHist.cxx:2173
 AliUEHist.cxx:2174
 AliUEHist.cxx:2175
 AliUEHist.cxx:2176
 AliUEHist.cxx:2177
 AliUEHist.cxx:2178
 AliUEHist.cxx:2179
 AliUEHist.cxx:2180
 AliUEHist.cxx:2181
 AliUEHist.cxx:2182
 AliUEHist.cxx:2183
 AliUEHist.cxx:2184
 AliUEHist.cxx:2185
 AliUEHist.cxx:2186
 AliUEHist.cxx:2187
 AliUEHist.cxx:2188
 AliUEHist.cxx:2189
 AliUEHist.cxx:2190
 AliUEHist.cxx:2191
 AliUEHist.cxx:2192
 AliUEHist.cxx:2193
 AliUEHist.cxx:2194
 AliUEHist.cxx:2195
 AliUEHist.cxx:2196
 AliUEHist.cxx:2197
 AliUEHist.cxx:2198
 AliUEHist.cxx:2199
 AliUEHist.cxx:2200
 AliUEHist.cxx:2201
 AliUEHist.cxx:2202
 AliUEHist.cxx:2203
 AliUEHist.cxx:2204
 AliUEHist.cxx:2205
 AliUEHist.cxx:2206
 AliUEHist.cxx:2207
 AliUEHist.cxx:2208
 AliUEHist.cxx:2209
 AliUEHist.cxx:2210
 AliUEHist.cxx:2211
 AliUEHist.cxx:2212
 AliUEHist.cxx:2213
 AliUEHist.cxx:2214
 AliUEHist.cxx:2215
 AliUEHist.cxx:2216
 AliUEHist.cxx:2217
 AliUEHist.cxx:2218
 AliUEHist.cxx:2219
 AliUEHist.cxx:2220
 AliUEHist.cxx:2221
 AliUEHist.cxx:2222
 AliUEHist.cxx:2223
 AliUEHist.cxx:2224
 AliUEHist.cxx:2225
 AliUEHist.cxx:2226
 AliUEHist.cxx:2227
 AliUEHist.cxx:2228
 AliUEHist.cxx:2229
 AliUEHist.cxx:2230
 AliUEHist.cxx:2231
 AliUEHist.cxx:2232
 AliUEHist.cxx:2233
 AliUEHist.cxx:2234
 AliUEHist.cxx:2235
 AliUEHist.cxx:2236
 AliUEHist.cxx:2237
 AliUEHist.cxx:2238
 AliUEHist.cxx:2239
 AliUEHist.cxx:2240
 AliUEHist.cxx:2241
 AliUEHist.cxx:2242
 AliUEHist.cxx:2243
 AliUEHist.cxx:2244
 AliUEHist.cxx:2245
 AliUEHist.cxx:2246
 AliUEHist.cxx:2247
 AliUEHist.cxx:2248
 AliUEHist.cxx:2249
 AliUEHist.cxx:2250
 AliUEHist.cxx:2251
 AliUEHist.cxx:2252
 AliUEHist.cxx:2253
 AliUEHist.cxx:2254
 AliUEHist.cxx:2255
 AliUEHist.cxx:2256
 AliUEHist.cxx:2257
 AliUEHist.cxx:2258
 AliUEHist.cxx:2259
 AliUEHist.cxx:2260
 AliUEHist.cxx:2261
 AliUEHist.cxx:2262
 AliUEHist.cxx:2263
 AliUEHist.cxx:2264
 AliUEHist.cxx:2265
 AliUEHist.cxx:2266
 AliUEHist.cxx:2267
 AliUEHist.cxx:2268
 AliUEHist.cxx:2269
 AliUEHist.cxx:2270
 AliUEHist.cxx:2271
 AliUEHist.cxx:2272
 AliUEHist.cxx:2273
 AliUEHist.cxx:2274
 AliUEHist.cxx:2275
 AliUEHist.cxx:2276
 AliUEHist.cxx:2277
 AliUEHist.cxx:2278
 AliUEHist.cxx:2279
 AliUEHist.cxx:2280
 AliUEHist.cxx:2281
 AliUEHist.cxx:2282
 AliUEHist.cxx:2283
 AliUEHist.cxx:2284
 AliUEHist.cxx:2285
 AliUEHist.cxx:2286
 AliUEHist.cxx:2287
 AliUEHist.cxx:2288
 AliUEHist.cxx:2289
 AliUEHist.cxx:2290
 AliUEHist.cxx:2291
 AliUEHist.cxx:2292
 AliUEHist.cxx:2293
 AliUEHist.cxx:2294
 AliUEHist.cxx:2295
 AliUEHist.cxx:2296
 AliUEHist.cxx:2297
 AliUEHist.cxx:2298
 AliUEHist.cxx:2299
 AliUEHist.cxx:2300
 AliUEHist.cxx:2301
 AliUEHist.cxx:2302
 AliUEHist.cxx:2303
 AliUEHist.cxx:2304
 AliUEHist.cxx:2305
 AliUEHist.cxx:2306
 AliUEHist.cxx:2307
 AliUEHist.cxx:2308
 AliUEHist.cxx:2309
 AliUEHist.cxx:2310
 AliUEHist.cxx:2311
 AliUEHist.cxx:2312
 AliUEHist.cxx:2313
 AliUEHist.cxx:2314
 AliUEHist.cxx:2315
 AliUEHist.cxx:2316
 AliUEHist.cxx:2317
 AliUEHist.cxx:2318
 AliUEHist.cxx:2319
 AliUEHist.cxx:2320
 AliUEHist.cxx:2321
 AliUEHist.cxx:2322
 AliUEHist.cxx:2323
 AliUEHist.cxx:2324
 AliUEHist.cxx:2325
 AliUEHist.cxx:2326
 AliUEHist.cxx:2327
 AliUEHist.cxx:2328
 AliUEHist.cxx:2329
 AliUEHist.cxx:2330
 AliUEHist.cxx:2331
 AliUEHist.cxx:2332
 AliUEHist.cxx:2333
 AliUEHist.cxx:2334
 AliUEHist.cxx:2335
 AliUEHist.cxx:2336
 AliUEHist.cxx:2337
 AliUEHist.cxx:2338
 AliUEHist.cxx:2339
 AliUEHist.cxx:2340
 AliUEHist.cxx:2341
 AliUEHist.cxx:2342
 AliUEHist.cxx:2343
 AliUEHist.cxx:2344
 AliUEHist.cxx:2345
 AliUEHist.cxx:2346
 AliUEHist.cxx:2347
 AliUEHist.cxx:2348
 AliUEHist.cxx:2349
 AliUEHist.cxx:2350
 AliUEHist.cxx:2351
 AliUEHist.cxx:2352
 AliUEHist.cxx:2353
 AliUEHist.cxx:2354
 AliUEHist.cxx:2355
 AliUEHist.cxx:2356
 AliUEHist.cxx:2357
 AliUEHist.cxx:2358
 AliUEHist.cxx:2359
 AliUEHist.cxx:2360
 AliUEHist.cxx:2361
 AliUEHist.cxx:2362
 AliUEHist.cxx:2363
 AliUEHist.cxx:2364
 AliUEHist.cxx:2365
 AliUEHist.cxx:2366
 AliUEHist.cxx:2367
 AliUEHist.cxx:2368
 AliUEHist.cxx:2369
 AliUEHist.cxx:2370
 AliUEHist.cxx:2371
 AliUEHist.cxx:2372
 AliUEHist.cxx:2373
 AliUEHist.cxx:2374
 AliUEHist.cxx:2375
 AliUEHist.cxx:2376
 AliUEHist.cxx:2377
 AliUEHist.cxx:2378
 AliUEHist.cxx:2379
 AliUEHist.cxx:2380
 AliUEHist.cxx:2381
 AliUEHist.cxx:2382
 AliUEHist.cxx:2383
 AliUEHist.cxx:2384
 AliUEHist.cxx:2385
 AliUEHist.cxx:2386
 AliUEHist.cxx:2387
 AliUEHist.cxx:2388
 AliUEHist.cxx:2389
 AliUEHist.cxx:2390
 AliUEHist.cxx:2391
 AliUEHist.cxx:2392
 AliUEHist.cxx:2393
 AliUEHist.cxx:2394
 AliUEHist.cxx:2395
 AliUEHist.cxx:2396
 AliUEHist.cxx:2397
 AliUEHist.cxx:2398
 AliUEHist.cxx:2399
 AliUEHist.cxx:2400
 AliUEHist.cxx:2401
 AliUEHist.cxx:2402
 AliUEHist.cxx:2403
 AliUEHist.cxx:2404
 AliUEHist.cxx:2405
 AliUEHist.cxx:2406
 AliUEHist.cxx:2407
 AliUEHist.cxx:2408
 AliUEHist.cxx:2409
 AliUEHist.cxx:2410
 AliUEHist.cxx:2411
 AliUEHist.cxx:2412
 AliUEHist.cxx:2413
 AliUEHist.cxx:2414
 AliUEHist.cxx:2415
 AliUEHist.cxx:2416
 AliUEHist.cxx:2417
 AliUEHist.cxx:2418
 AliUEHist.cxx:2419
 AliUEHist.cxx:2420
 AliUEHist.cxx:2421
 AliUEHist.cxx:2422
 AliUEHist.cxx:2423
 AliUEHist.cxx:2424
 AliUEHist.cxx:2425
 AliUEHist.cxx:2426
 AliUEHist.cxx:2427
 AliUEHist.cxx:2428
 AliUEHist.cxx:2429
 AliUEHist.cxx:2430
 AliUEHist.cxx:2431
 AliUEHist.cxx:2432
 AliUEHist.cxx:2433
 AliUEHist.cxx:2434
 AliUEHist.cxx:2435
 AliUEHist.cxx:2436
 AliUEHist.cxx:2437
 AliUEHist.cxx:2438
 AliUEHist.cxx:2439
 AliUEHist.cxx:2440
 AliUEHist.cxx:2441
 AliUEHist.cxx:2442
 AliUEHist.cxx:2443
 AliUEHist.cxx:2444
 AliUEHist.cxx:2445
 AliUEHist.cxx:2446
 AliUEHist.cxx:2447
 AliUEHist.cxx:2448
 AliUEHist.cxx:2449
 AliUEHist.cxx:2450
 AliUEHist.cxx:2451
 AliUEHist.cxx:2452
 AliUEHist.cxx:2453
 AliUEHist.cxx:2454
 AliUEHist.cxx:2455
 AliUEHist.cxx:2456
 AliUEHist.cxx:2457
 AliUEHist.cxx:2458
 AliUEHist.cxx:2459
 AliUEHist.cxx:2460
 AliUEHist.cxx:2461
 AliUEHist.cxx:2462
 AliUEHist.cxx:2463
 AliUEHist.cxx:2464
 AliUEHist.cxx:2465
 AliUEHist.cxx:2466
 AliUEHist.cxx:2467
 AliUEHist.cxx:2468
 AliUEHist.cxx:2469
 AliUEHist.cxx:2470
 AliUEHist.cxx:2471
 AliUEHist.cxx:2472
 AliUEHist.cxx:2473
 AliUEHist.cxx:2474
 AliUEHist.cxx:2475
 AliUEHist.cxx:2476
 AliUEHist.cxx:2477
 AliUEHist.cxx:2478
 AliUEHist.cxx:2479
 AliUEHist.cxx:2480
 AliUEHist.cxx:2481
 AliUEHist.cxx:2482
 AliUEHist.cxx:2483
 AliUEHist.cxx:2484
 AliUEHist.cxx:2485
 AliUEHist.cxx:2486
 AliUEHist.cxx:2487
 AliUEHist.cxx:2488
 AliUEHist.cxx:2489
 AliUEHist.cxx:2490
 AliUEHist.cxx:2491
 AliUEHist.cxx:2492
 AliUEHist.cxx:2493
 AliUEHist.cxx:2494
 AliUEHist.cxx:2495
 AliUEHist.cxx:2496
 AliUEHist.cxx:2497
 AliUEHist.cxx:2498
 AliUEHist.cxx:2499
 AliUEHist.cxx:2500
 AliUEHist.cxx:2501
 AliUEHist.cxx:2502
 AliUEHist.cxx:2503
 AliUEHist.cxx:2504
 AliUEHist.cxx:2505
 AliUEHist.cxx:2506
 AliUEHist.cxx:2507
 AliUEHist.cxx:2508
 AliUEHist.cxx:2509
 AliUEHist.cxx:2510
 AliUEHist.cxx:2511
 AliUEHist.cxx:2512
 AliUEHist.cxx:2513
 AliUEHist.cxx:2514
 AliUEHist.cxx:2515
 AliUEHist.cxx:2516
 AliUEHist.cxx:2517
 AliUEHist.cxx:2518
 AliUEHist.cxx:2519
 AliUEHist.cxx:2520
 AliUEHist.cxx:2521
 AliUEHist.cxx:2522
 AliUEHist.cxx:2523
 AliUEHist.cxx:2524
 AliUEHist.cxx:2525
 AliUEHist.cxx:2526
 AliUEHist.cxx:2527
 AliUEHist.cxx:2528
 AliUEHist.cxx:2529
 AliUEHist.cxx:2530
 AliUEHist.cxx:2531
 AliUEHist.cxx:2532
 AliUEHist.cxx:2533
 AliUEHist.cxx:2534
 AliUEHist.cxx:2535
 AliUEHist.cxx:2536
 AliUEHist.cxx:2537
 AliUEHist.cxx:2538
 AliUEHist.cxx:2539
 AliUEHist.cxx:2540
 AliUEHist.cxx:2541
 AliUEHist.cxx:2542
 AliUEHist.cxx:2543
 AliUEHist.cxx:2544
 AliUEHist.cxx:2545
 AliUEHist.cxx:2546
 AliUEHist.cxx:2547
 AliUEHist.cxx:2548
 AliUEHist.cxx:2549
 AliUEHist.cxx:2550
 AliUEHist.cxx:2551
 AliUEHist.cxx:2552
 AliUEHist.cxx:2553
 AliUEHist.cxx:2554
 AliUEHist.cxx:2555
 AliUEHist.cxx:2556
 AliUEHist.cxx:2557
 AliUEHist.cxx:2558
 AliUEHist.cxx:2559
 AliUEHist.cxx:2560
 AliUEHist.cxx:2561
 AliUEHist.cxx:2562
 AliUEHist.cxx:2563
 AliUEHist.cxx:2564
 AliUEHist.cxx:2565
 AliUEHist.cxx:2566
 AliUEHist.cxx:2567
 AliUEHist.cxx:2568
 AliUEHist.cxx:2569
 AliUEHist.cxx:2570
 AliUEHist.cxx:2571
 AliUEHist.cxx:2572
 AliUEHist.cxx:2573
 AliUEHist.cxx:2574
 AliUEHist.cxx:2575
 AliUEHist.cxx:2576
 AliUEHist.cxx:2577
 AliUEHist.cxx:2578
 AliUEHist.cxx:2579
 AliUEHist.cxx:2580
 AliUEHist.cxx:2581
 AliUEHist.cxx:2582
 AliUEHist.cxx:2583
 AliUEHist.cxx:2584
 AliUEHist.cxx:2585
 AliUEHist.cxx:2586
 AliUEHist.cxx:2587
 AliUEHist.cxx:2588
 AliUEHist.cxx:2589
 AliUEHist.cxx:2590
 AliUEHist.cxx:2591
 AliUEHist.cxx:2592
 AliUEHist.cxx:2593
 AliUEHist.cxx:2594
 AliUEHist.cxx:2595
 AliUEHist.cxx:2596
 AliUEHist.cxx:2597
 AliUEHist.cxx:2598
 AliUEHist.cxx:2599
 AliUEHist.cxx:2600
 AliUEHist.cxx:2601
 AliUEHist.cxx:2602
 AliUEHist.cxx:2603
 AliUEHist.cxx:2604
 AliUEHist.cxx:2605
 AliUEHist.cxx:2606
 AliUEHist.cxx:2607
 AliUEHist.cxx:2608
 AliUEHist.cxx:2609
 AliUEHist.cxx:2610
 AliUEHist.cxx:2611
 AliUEHist.cxx:2612
 AliUEHist.cxx:2613
 AliUEHist.cxx:2614
 AliUEHist.cxx:2615
 AliUEHist.cxx:2616
 AliUEHist.cxx:2617
 AliUEHist.cxx:2618
 AliUEHist.cxx:2619
 AliUEHist.cxx:2620
 AliUEHist.cxx:2621
 AliUEHist.cxx:2622
 AliUEHist.cxx:2623
 AliUEHist.cxx:2624
 AliUEHist.cxx:2625
 AliUEHist.cxx:2626
 AliUEHist.cxx:2627
 AliUEHist.cxx:2628
 AliUEHist.cxx:2629
 AliUEHist.cxx:2630
 AliUEHist.cxx:2631
 AliUEHist.cxx:2632
 AliUEHist.cxx:2633
 AliUEHist.cxx:2634
 AliUEHist.cxx:2635
 AliUEHist.cxx:2636
 AliUEHist.cxx:2637
 AliUEHist.cxx:2638
 AliUEHist.cxx:2639
 AliUEHist.cxx:2640
 AliUEHist.cxx:2641
 AliUEHist.cxx:2642
 AliUEHist.cxx:2643
 AliUEHist.cxx:2644
 AliUEHist.cxx:2645
 AliUEHist.cxx:2646
 AliUEHist.cxx:2647
 AliUEHist.cxx:2648
 AliUEHist.cxx:2649
 AliUEHist.cxx:2650
 AliUEHist.cxx:2651
 AliUEHist.cxx:2652
 AliUEHist.cxx:2653
 AliUEHist.cxx:2654
 AliUEHist.cxx:2655
 AliUEHist.cxx:2656
 AliUEHist.cxx:2657
 AliUEHist.cxx:2658
 AliUEHist.cxx:2659
 AliUEHist.cxx:2660
 AliUEHist.cxx:2661
 AliUEHist.cxx:2662
 AliUEHist.cxx:2663
 AliUEHist.cxx:2664
 AliUEHist.cxx:2665
 AliUEHist.cxx:2666
 AliUEHist.cxx:2667
 AliUEHist.cxx:2668
 AliUEHist.cxx:2669
 AliUEHist.cxx:2670
 AliUEHist.cxx:2671
 AliUEHist.cxx:2672
 AliUEHist.cxx:2673
 AliUEHist.cxx:2674
 AliUEHist.cxx:2675
 AliUEHist.cxx:2676
 AliUEHist.cxx:2677
 AliUEHist.cxx:2678
 AliUEHist.cxx:2679
 AliUEHist.cxx:2680
 AliUEHist.cxx:2681
 AliUEHist.cxx:2682
 AliUEHist.cxx:2683
 AliUEHist.cxx:2684
 AliUEHist.cxx:2685
 AliUEHist.cxx:2686
 AliUEHist.cxx:2687
 AliUEHist.cxx:2688
 AliUEHist.cxx:2689
 AliUEHist.cxx:2690
 AliUEHist.cxx:2691
 AliUEHist.cxx:2692
 AliUEHist.cxx:2693
 AliUEHist.cxx:2694
 AliUEHist.cxx:2695
 AliUEHist.cxx:2696
 AliUEHist.cxx:2697
 AliUEHist.cxx:2698
 AliUEHist.cxx:2699
 AliUEHist.cxx:2700
 AliUEHist.cxx:2701
 AliUEHist.cxx:2702
 AliUEHist.cxx:2703
 AliUEHist.cxx:2704
 AliUEHist.cxx:2705
 AliUEHist.cxx:2706
 AliUEHist.cxx:2707
 AliUEHist.cxx:2708
 AliUEHist.cxx:2709
 AliUEHist.cxx:2710
 AliUEHist.cxx:2711
 AliUEHist.cxx:2712
 AliUEHist.cxx:2713
 AliUEHist.cxx:2714
 AliUEHist.cxx:2715
 AliUEHist.cxx:2716
 AliUEHist.cxx:2717
 AliUEHist.cxx:2718
 AliUEHist.cxx:2719
 AliUEHist.cxx:2720
 AliUEHist.cxx:2721
 AliUEHist.cxx:2722
 AliUEHist.cxx:2723
 AliUEHist.cxx:2724
 AliUEHist.cxx:2725
 AliUEHist.cxx:2726
 AliUEHist.cxx:2727
 AliUEHist.cxx:2728
 AliUEHist.cxx:2729
 AliUEHist.cxx:2730
 AliUEHist.cxx:2731
 AliUEHist.cxx:2732
 AliUEHist.cxx:2733
 AliUEHist.cxx:2734
 AliUEHist.cxx:2735
 AliUEHist.cxx:2736
 AliUEHist.cxx:2737
 AliUEHist.cxx:2738
 AliUEHist.cxx:2739
 AliUEHist.cxx:2740
 AliUEHist.cxx:2741
 AliUEHist.cxx:2742
 AliUEHist.cxx:2743
 AliUEHist.cxx:2744
 AliUEHist.cxx:2745
 AliUEHist.cxx:2746
 AliUEHist.cxx:2747
 AliUEHist.cxx:2748
 AliUEHist.cxx:2749
 AliUEHist.cxx:2750
 AliUEHist.cxx:2751
 AliUEHist.cxx:2752
 AliUEHist.cxx:2753
 AliUEHist.cxx:2754
 AliUEHist.cxx:2755
 AliUEHist.cxx:2756
 AliUEHist.cxx:2757
 AliUEHist.cxx:2758
 AliUEHist.cxx:2759
 AliUEHist.cxx:2760
 AliUEHist.cxx:2761
 AliUEHist.cxx:2762
 AliUEHist.cxx:2763
 AliUEHist.cxx:2764
 AliUEHist.cxx:2765
 AliUEHist.cxx:2766
 AliUEHist.cxx:2767
 AliUEHist.cxx:2768
 AliUEHist.cxx:2769
 AliUEHist.cxx:2770
 AliUEHist.cxx:2771
 AliUEHist.cxx:2772
 AliUEHist.cxx:2773
 AliUEHist.cxx:2774
 AliUEHist.cxx:2775
 AliUEHist.cxx:2776
 AliUEHist.cxx:2777
 AliUEHist.cxx:2778
 AliUEHist.cxx:2779
 AliUEHist.cxx:2780
 AliUEHist.cxx:2781
 AliUEHist.cxx:2782
 AliUEHist.cxx:2783
 AliUEHist.cxx:2784
 AliUEHist.cxx:2785
 AliUEHist.cxx:2786
 AliUEHist.cxx:2787
 AliUEHist.cxx:2788
 AliUEHist.cxx:2789
 AliUEHist.cxx:2790
 AliUEHist.cxx:2791
 AliUEHist.cxx:2792
 AliUEHist.cxx:2793
 AliUEHist.cxx:2794
 AliUEHist.cxx:2795
 AliUEHist.cxx:2796
 AliUEHist.cxx:2797
 AliUEHist.cxx:2798
 AliUEHist.cxx:2799
 AliUEHist.cxx:2800
 AliUEHist.cxx:2801
 AliUEHist.cxx:2802
 AliUEHist.cxx:2803
 AliUEHist.cxx:2804
 AliUEHist.cxx:2805
 AliUEHist.cxx:2806
 AliUEHist.cxx:2807
 AliUEHist.cxx:2808
 AliUEHist.cxx:2809
 AliUEHist.cxx:2810
 AliUEHist.cxx:2811
 AliUEHist.cxx:2812
 AliUEHist.cxx:2813
 AliUEHist.cxx:2814
 AliUEHist.cxx:2815
 AliUEHist.cxx:2816
 AliUEHist.cxx:2817
 AliUEHist.cxx:2818
 AliUEHist.cxx:2819
 AliUEHist.cxx:2820
 AliUEHist.cxx:2821
 AliUEHist.cxx:2822
 AliUEHist.cxx:2823
 AliUEHist.cxx:2824
 AliUEHist.cxx:2825
 AliUEHist.cxx:2826
 AliUEHist.cxx:2827
 AliUEHist.cxx:2828
 AliUEHist.cxx:2829
 AliUEHist.cxx:2830
 AliUEHist.cxx:2831
 AliUEHist.cxx:2832
 AliUEHist.cxx:2833
 AliUEHist.cxx:2834
 AliUEHist.cxx:2835
 AliUEHist.cxx:2836
 AliUEHist.cxx:2837
 AliUEHist.cxx:2838
 AliUEHist.cxx:2839
 AliUEHist.cxx:2840
 AliUEHist.cxx:2841
 AliUEHist.cxx:2842
 AliUEHist.cxx:2843
 AliUEHist.cxx:2844
 AliUEHist.cxx:2845
 AliUEHist.cxx:2846
 AliUEHist.cxx:2847
 AliUEHist.cxx:2848
 AliUEHist.cxx:2849
 AliUEHist.cxx:2850
 AliUEHist.cxx:2851
 AliUEHist.cxx:2852
 AliUEHist.cxx:2853
 AliUEHist.cxx:2854
 AliUEHist.cxx:2855
 AliUEHist.cxx:2856
 AliUEHist.cxx:2857
 AliUEHist.cxx:2858
 AliUEHist.cxx:2859
 AliUEHist.cxx:2860
 AliUEHist.cxx:2861
 AliUEHist.cxx:2862
 AliUEHist.cxx:2863
 AliUEHist.cxx:2864
 AliUEHist.cxx:2865
 AliUEHist.cxx:2866
 AliUEHist.cxx:2867
 AliUEHist.cxx:2868
 AliUEHist.cxx:2869
 AliUEHist.cxx:2870
 AliUEHist.cxx:2871
 AliUEHist.cxx:2872
 AliUEHist.cxx:2873
 AliUEHist.cxx:2874
 AliUEHist.cxx:2875
 AliUEHist.cxx:2876
 AliUEHist.cxx:2877
 AliUEHist.cxx:2878
 AliUEHist.cxx:2879
 AliUEHist.cxx:2880
 AliUEHist.cxx:2881
 AliUEHist.cxx:2882
 AliUEHist.cxx:2883
 AliUEHist.cxx:2884
 AliUEHist.cxx:2885
 AliUEHist.cxx:2886
 AliUEHist.cxx:2887
 AliUEHist.cxx:2888
 AliUEHist.cxx:2889
 AliUEHist.cxx:2890
 AliUEHist.cxx:2891
 AliUEHist.cxx:2892
 AliUEHist.cxx:2893
 AliUEHist.cxx:2894
 AliUEHist.cxx:2895
 AliUEHist.cxx:2896
 AliUEHist.cxx:2897
 AliUEHist.cxx:2898
 AliUEHist.cxx:2899
 AliUEHist.cxx:2900
 AliUEHist.cxx:2901
 AliUEHist.cxx:2902
 AliUEHist.cxx:2903
 AliUEHist.cxx:2904
 AliUEHist.cxx:2905
 AliUEHist.cxx:2906
 AliUEHist.cxx:2907
 AliUEHist.cxx:2908
 AliUEHist.cxx:2909
 AliUEHist.cxx:2910
 AliUEHist.cxx:2911
 AliUEHist.cxx:2912
 AliUEHist.cxx:2913
 AliUEHist.cxx:2914
 AliUEHist.cxx:2915
 AliUEHist.cxx:2916
 AliUEHist.cxx:2917
 AliUEHist.cxx:2918
 AliUEHist.cxx:2919
 AliUEHist.cxx:2920
 AliUEHist.cxx:2921
 AliUEHist.cxx:2922
 AliUEHist.cxx:2923
 AliUEHist.cxx:2924
 AliUEHist.cxx:2925
 AliUEHist.cxx:2926
 AliUEHist.cxx:2927
 AliUEHist.cxx:2928
 AliUEHist.cxx:2929
 AliUEHist.cxx:2930
 AliUEHist.cxx:2931
 AliUEHist.cxx:2932
 AliUEHist.cxx:2933
 AliUEHist.cxx:2934
 AliUEHist.cxx:2935
 AliUEHist.cxx:2936
 AliUEHist.cxx:2937
 AliUEHist.cxx:2938
 AliUEHist.cxx:2939
 AliUEHist.cxx:2940
 AliUEHist.cxx:2941
 AliUEHist.cxx:2942
 AliUEHist.cxx:2943
 AliUEHist.cxx:2944
 AliUEHist.cxx:2945
 AliUEHist.cxx:2946
 AliUEHist.cxx:2947
 AliUEHist.cxx:2948
 AliUEHist.cxx:2949
 AliUEHist.cxx:2950
 AliUEHist.cxx:2951
 AliUEHist.cxx:2952
 AliUEHist.cxx:2953
 AliUEHist.cxx:2954
 AliUEHist.cxx:2955
 AliUEHist.cxx:2956
 AliUEHist.cxx:2957
 AliUEHist.cxx:2958
 AliUEHist.cxx:2959
 AliUEHist.cxx:2960
 AliUEHist.cxx:2961
 AliUEHist.cxx:2962
 AliUEHist.cxx:2963
 AliUEHist.cxx:2964
 AliUEHist.cxx:2965
 AliUEHist.cxx:2966
 AliUEHist.cxx:2967
 AliUEHist.cxx:2968
 AliUEHist.cxx:2969
 AliUEHist.cxx:2970
 AliUEHist.cxx:2971
 AliUEHist.cxx:2972
 AliUEHist.cxx:2973
 AliUEHist.cxx:2974
 AliUEHist.cxx:2975
 AliUEHist.cxx:2976
 AliUEHist.cxx:2977
 AliUEHist.cxx:2978
 AliUEHist.cxx:2979
 AliUEHist.cxx:2980
 AliUEHist.cxx:2981
 AliUEHist.cxx:2982
 AliUEHist.cxx:2983
 AliUEHist.cxx:2984
 AliUEHist.cxx:2985
 AliUEHist.cxx:2986
 AliUEHist.cxx:2987
 AliUEHist.cxx:2988
 AliUEHist.cxx:2989
 AliUEHist.cxx:2990
 AliUEHist.cxx:2991
 AliUEHist.cxx:2992
 AliUEHist.cxx:2993
 AliUEHist.cxx:2994
 AliUEHist.cxx:2995
 AliUEHist.cxx:2996
 AliUEHist.cxx:2997
 AliUEHist.cxx:2998
 AliUEHist.cxx:2999
 AliUEHist.cxx:3000
 AliUEHist.cxx:3001
 AliUEHist.cxx:3002
 AliUEHist.cxx:3003
 AliUEHist.cxx:3004
 AliUEHist.cxx:3005
 AliUEHist.cxx:3006
 AliUEHist.cxx:3007
 AliUEHist.cxx:3008
 AliUEHist.cxx:3009
 AliUEHist.cxx:3010
 AliUEHist.cxx:3011
 AliUEHist.cxx:3012
 AliUEHist.cxx:3013
 AliUEHist.cxx:3014
 AliUEHist.cxx:3015
 AliUEHist.cxx:3016
 AliUEHist.cxx:3017
 AliUEHist.cxx:3018
 AliUEHist.cxx:3019
 AliUEHist.cxx:3020
 AliUEHist.cxx:3021
 AliUEHist.cxx:3022
 AliUEHist.cxx:3023
 AliUEHist.cxx:3024
 AliUEHist.cxx:3025
 AliUEHist.cxx:3026
 AliUEHist.cxx:3027
 AliUEHist.cxx:3028
 AliUEHist.cxx:3029
 AliUEHist.cxx:3030
 AliUEHist.cxx:3031
 AliUEHist.cxx:3032
 AliUEHist.cxx:3033
 AliUEHist.cxx:3034
 AliUEHist.cxx:3035
 AliUEHist.cxx:3036
 AliUEHist.cxx:3037
 AliUEHist.cxx:3038
 AliUEHist.cxx:3039
 AliUEHist.cxx:3040
 AliUEHist.cxx:3041
 AliUEHist.cxx:3042
 AliUEHist.cxx:3043
 AliUEHist.cxx:3044
 AliUEHist.cxx:3045
 AliUEHist.cxx:3046
 AliUEHist.cxx:3047
 AliUEHist.cxx:3048
 AliUEHist.cxx:3049
 AliUEHist.cxx:3050
 AliUEHist.cxx:3051
 AliUEHist.cxx:3052
 AliUEHist.cxx:3053
 AliUEHist.cxx:3054
 AliUEHist.cxx:3055
 AliUEHist.cxx:3056
 AliUEHist.cxx:3057
 AliUEHist.cxx:3058
 AliUEHist.cxx:3059
 AliUEHist.cxx:3060
 AliUEHist.cxx:3061
 AliUEHist.cxx:3062
 AliUEHist.cxx:3063
 AliUEHist.cxx:3064
 AliUEHist.cxx:3065
 AliUEHist.cxx:3066
 AliUEHist.cxx:3067
 AliUEHist.cxx:3068
 AliUEHist.cxx:3069
 AliUEHist.cxx:3070
 AliUEHist.cxx:3071
 AliUEHist.cxx:3072
 AliUEHist.cxx:3073
 AliUEHist.cxx:3074
 AliUEHist.cxx:3075
 AliUEHist.cxx:3076
 AliUEHist.cxx:3077
 AliUEHist.cxx:3078
 AliUEHist.cxx:3079
 AliUEHist.cxx:3080
 AliUEHist.cxx:3081
 AliUEHist.cxx:3082
 AliUEHist.cxx:3083
 AliUEHist.cxx:3084
 AliUEHist.cxx:3085
 AliUEHist.cxx:3086
 AliUEHist.cxx:3087
 AliUEHist.cxx:3088
 AliUEHist.cxx:3089
 AliUEHist.cxx:3090
 AliUEHist.cxx:3091
 AliUEHist.cxx:3092
 AliUEHist.cxx:3093
 AliUEHist.cxx:3094
 AliUEHist.cxx:3095
 AliUEHist.cxx:3096
 AliUEHist.cxx:3097
 AliUEHist.cxx:3098
 AliUEHist.cxx:3099
 AliUEHist.cxx:3100
 AliUEHist.cxx:3101
 AliUEHist.cxx:3102
 AliUEHist.cxx:3103
 AliUEHist.cxx:3104
 AliUEHist.cxx:3105
 AliUEHist.cxx:3106
 AliUEHist.cxx:3107
 AliUEHist.cxx:3108