ROOT logo
#include "AliForwardMultDists.h" 
#include <AliForwardUtil.h> 
#include <AliAODForwardMult.h>
#include <AliAODCentralMult.h>
#include <AliAODEvent.h>
#include <AliLog.h>
#include <TH1.h>
#include <TH2.h>
#include <TVector2.h>
#include <THStack.h>
#include <TParameter.h>
#include <TError.h>
#include <iostream>
#include <iomanip> 

//====================================================================
namespace {
  /**
   * Marker styles 
   */
  enum { 
    kSolid        = 0x000, 
    kHollow       = 0x001, 
    kCircle       = 0x002,
    kSquare       = 0x004, 
    kUpTriangle   = 0x006, 
    kDownTriangle = 0x008, 
    kDiamond      = 0x00a,
    kCross        = 0x00c,
    kStar         = 0x00e
  };
  /** 
   * Get a ROOT marker style from bit options 
   * 
   * @param bits Bit mask of options 
   * 
   * @return ROOT marker style
   */
  Int_t GetMarkerStyle(UShort_t bits)
  {
    Int_t  base   = bits & (0xFE);
    Bool_t hollow = bits & kHollow;
    switch (base) { 
    case kCircle:       return (hollow ? 24 : 20);
    case kSquare:       return (hollow ? 25 : 21);
    case kUpTriangle:   return (hollow ? 26 : 22);
    case kDownTriangle: return (hollow ? 32 : 23);
    case kDiamond:      return (hollow ? 27 : 33); 
    case kCross:        return (hollow ? 28 : 34); 
    case kStar:         return (hollow ? 30 : 29); 
    }
    return 1;
  }
#if 0
  /** 
   * Get the marker option bits from a ROOT style 
   * 
   * @param style ROOT style 
   * 
   * @return Pattern of marker options
   */
  UShort_t GetMarkerBits(Int_t style) 
  { 
    UShort_t bits = 0;
    switch (style) { 
    case 24: case 25: case 26: case 27: case 28: case 30: case 32: 
      bits |= kHollow; break;
    }
    switch (style) { 
    case 20: case 24: bits |= kCircle;       break;
    case 21: case 25: bits |= kSquare;       break;
    case 22: case 26: bits |= kUpTriangle;   break;
    case 23: case 32: bits |= kDownTriangle; break;
    case 27: case 33: bits |= kDiamond;      break;
    case 28: case 34: bits |= kCross;        break;
    case 29: case 30: bits |= kStar;         break;
    }
    return bits;
  }
#endif 
  static Int_t GetIndexMarker(Int_t idx)
  {
    const UShort_t nMarkers = 7;
    UShort_t markers[] = { 
      kCircle, 
      kSquare, 
      kUpTriangle, 
      kDownTriangle, 
      kDiamond,
      kCross,
      kStar 
    };

    return markers[idx % nMarkers];
  }
#if 0
  /** 
   * Flip the 'hollow-ness' of a marker 
   * 
   * @param style ROOT Style 
   * 
   * @return ROOT style
   */
  Int_t FlipHollowStyle(Int_t style) 
  {
    UShort_t bits = GetMarkerBits(style);
    Int_t    ret  = GetMarkerStyle(bits ^ kHollow);
    return ret;
  }
#endif
}

//====================================================================
AliForwardMultDists::BinSpec::BinSpec(Double_t etaMin, 
				      Double_t etaMax, 
				      Double_t nchLow)
  : fEtaMin(etaMin), fEtaMax(etaMax), fLow(nchLow), fN(0), fD(0), fAxis(1,0,1)
{
}
//____________________________________________________________________
void
AliForwardMultDists::BinSpec::Push(UShort_t n, Double_t d)
{
  Int_t l = fN.GetSize();
  fN.Set(l+1); // Not terribly efficient, but that's ok because we do
  fD.Set(l+1); // this infrequently 
  fN[l] = n;
  fD[l] = d;
}
//____________________________________________________________________
const TAxis&
AliForwardMultDists::BinSpec::Axis() const
{
  if (fAxis.GetNbins() > 1) return fAxis;
  if (fN.GetSize() <= 0) return fAxis;
  if (fN.GetSize() == 1) { 
    // Exactly one spec, 
    fAxis.Set(fN[0], fLow, fN[0]*fD[0]+fLow);
  }
  else { 
    Int_t n = Int_t(fN.GetSum());
    Int_t l = fN.GetSize();
    Int_t i = 0;
    TArrayD b(n+1);
    b[0]    = fLow;
    for (Int_t j = 0; j < l; j++) { 
      for (Int_t k = 0; k < fN[j]; k++) {
	b[i+1] = b[i] + fD[j];
	i++;
      }
    }
    if (i != n) { 
      ::Warning("Axis", "Assigned bins, and number of bins not equal");
      n = TMath::Min(i, n);
    }
    fAxis.Set(n, b.GetArray());
  }
  return fAxis;
}

//====================================================================
AliForwardMultDists::AliForwardMultDists()
  : AliBaseAODTask(), 
    fBins(), 
    fSymmetric(0),
    fNegative(0), 
    fPositive(0),
    fMCVertex(0),
    fDiag(0),
    fForwardCache(0),
    fCentralCache(0),
    fMCCache(0),
    fUsePhiAcc(true),
    fIsSelected(false)
{}

//____________________________________________________________________
AliForwardMultDists::AliForwardMultDists(const char* name)
  : AliBaseAODTask(name,"AliForwardMultDists"),
    fBins(), 
    fSymmetric(0),
    fNegative(0), 
    fPositive(0),
    fMCVertex(0),
    fDiag(0),
    fForwardCache(0),
    fCentralCache(0),
    fMCCache(0),
    fUsePhiAcc(true),
    fIsSelected(false)
{
  /* 
   * User constructor 
   * 
   * @param name Name of the task 
   */
}


//____________________________________________________________________
Bool_t
AliForwardMultDists::Book()
{
  /* 
   * Create output objects - called at start of job in slave 
   * 
   */
  return true;
}
//____________________________________________________________________
Bool_t
AliForwardMultDists::PreData()
{
  /* 
   * Set-up internal structures on first seen event 
   * 
   */
  AliAODEvent*       aod     = AliForwardUtil::GetAODEvent(this);
  AliAODForwardMult* forward = GetForward(*aod);
  const TH2D&        hist    = forward->GetHistogram();
  Bool_t             useMC   = GetPrimary(*aod) != 0;

  fSums->Add(AliForwardUtil::MakeParameter("minIpZ", fMinIpZ));
  fSums->Add(AliForwardUtil::MakeParameter("maxIpZ", fMaxIpZ));

  const TAxis* xaxis = hist.GetXaxis();
  if (!xaxis->GetXbins() || xaxis->GetXbins()->GetSize() <= 0) {
    fForwardCache = new TH1D("forwardCache", "Projection of Forward data", 
			     xaxis->GetNbins(), xaxis->GetXmin(), 
			     xaxis->GetXmax());
    fCentralCache = new TH1D("centralCache", "Projection of Central data", 
			     xaxis->GetNbins(), xaxis->GetXmin(), 
			     xaxis->GetXmax());
    if (useMC)
      fMCCache = new TH1D("mcCache", "Projection of Mc data", 
			  xaxis->GetNbins(), xaxis->GetXmin(), 
			  xaxis->GetXmax());
  }
  else { 
    fForwardCache = new TH1D("forwardCache", "Projection of Forward data", 
			     xaxis->GetNbins(),xaxis->GetXbins()->GetArray());
    fCentralCache = new TH1D("centralCache", "Projection of Central data", 
			     xaxis->GetNbins(),xaxis->GetXbins()->GetArray());
    if (useMC) 
      fMCCache = new TH1D("mcCache", "Projection of Mc data", 
			  xaxis->GetNbins(),xaxis->GetXbins()->GetArray());
  }
  fForwardCache->SetDirectory(0);
  fForwardCache->GetXaxis()->SetTitle("#eta");
  fForwardCache->GetYaxis()->SetTitle("#sum#frac{d^{2}N}{d#etadphi}");
  fForwardCache->Sumw2();
  fCentralCache->SetDirectory(0);
  fCentralCache->GetXaxis()->SetTitle("#eta");
  fCentralCache->GetYaxis()->SetTitle("#sum#frac{d^{2}N}{d#etadphi}");
  fCentralCache->Sumw2();

  if (useMC) {
    fMCCache->SetDirectory(0);
    fMCCache->GetXaxis()->SetTitle("#eta");
    fMCCache->GetYaxis()->SetTitle("#sum#frac{d^{2}N}{d#etadphi}");
    fMCCache->Sumw2();

    fMCVertex = static_cast<TH1*>(fVertex->Clone("mcVertex"));
    fMCVertex->SetTitle("Vertex distribution from MC");
    fMCVertex->SetDirectory(0);
    fMCVertex->SetFillColor(kBlue+2);
    fSums->Add(fMCVertex);
  }

  UShort_t xBase = kTrigger-1;
  UShort_t yBase = kAnalysis-1;
  fDiag = new TH2I("diagnostics", "Event selection", 
		   kTriggerVertex-xBase, kTrigger-.5,  kTriggerVertex+.5, 
		   kTriggerVertex-yBase, kAnalysis-.5, kTriggerVertex+.5);
  fDiag->SetDirectory(0);
  fDiag->GetXaxis()->SetTitle("Selection");
  fDiag->GetXaxis()->SetBinLabel(kTrigger      -xBase, "Trigger");
  fDiag->GetXaxis()->SetBinLabel(kVertex       -xBase, "Vertex");
  fDiag->GetXaxis()->SetBinLabel(kTriggerVertex-xBase, "Trigger+Vertex");
  fDiag->GetYaxis()->SetTitle("Type/MC selection");
  fDiag->GetYaxis()->SetBinLabel(kAnalysis     -yBase, "Analysis");
  fDiag->GetYaxis()->SetBinLabel(kMC           -yBase, "MC");
  fDiag->GetYaxis()->SetBinLabel(kTrigger      -yBase, "MC Trigger");
  fDiag->GetYaxis()->SetBinLabel(kVertex       -yBase, "MC Vertex");
  fDiag->GetYaxis()->SetBinLabel(kTriggerVertex-yBase, "MC Trigger+Vertex");
  fDiag->SetMarkerSize(3);
  fDiag->SetMarkerColor(kWhite);
  fSums->Add(fDiag);

  TIter   next(&fBins);
  EtaBin* bin = 0;
  while ((bin = static_cast<EtaBin*>(next()))) {
    bin->SetupForData(fSums, hist, useMC);
  }
  return true;
}
//____________________________________________________________________
Bool_t
AliForwardMultDists::Event(AliAODEvent& aod)
{
  /* 
   * Analyse a single event 
   * 
   * @param aod Input event
   */
  AliAODForwardMult* forward = GetForward(aod, false, true);
  if (!forward) return false;
    
  AliAODCentralMult* central = GetCentral(aod, false, true);
  if (!central) return false;
    
  TH2* primary = GetPrimary(aod);

  const TH2& forwardData = forward->GetHistogram();
  const TH2& centralData = central->GetHistogram();

  Double_t vz    = forward->GetIpZ();
  Bool_t   trg   = forward->IsTriggerBits(fTriggerMask);
  Bool_t   vtx   = (vz <= fMaxIpZ && vz >= fMinIpZ);
  Bool_t   ok    = true;  // Should bins process this event?
  Bool_t   mcTrg = false;
  Bool_t   mcVtx = false;
  // If we have MC inpunt
  if (primary) {
    // For MC, we need to check if we should process the event for
    // MC information or not.
    if ((fTriggerMask & (AliAODForwardMult::kV0AND|AliAODForwardMult::kNSD))
	&& !forward->IsTriggerBits(AliAODForwardMult::kMCNSD)) 
      // Bail out if this event is not MC NSD event
      ok = false;
    else 
      mcTrg = true;
    Double_t mcVz = primary->GetBinContent(0,0);
    fMCVertex->Fill(mcVz);
    if (mcVz > fMaxIpZ || mcVz < fMinIpZ) 
      // Bail out if this event was not in the valid range 
      ok = false;
    else 
      mcVtx = true;
  }
  // Fill diagnostics 
  if (trg) { 
    fDiag->Fill(kTrigger, kAnalysis);
    if (mcTrg)          fDiag->Fill(kTrigger,       kTrigger);
    if (mcVtx)          fDiag->Fill(kTrigger,       kVertex);
    if (mcTrg && mcVtx) fDiag->Fill(kTrigger,       kTriggerVertex);
  }
  if (vtx) { 
    fDiag->Fill(kVertex, kAnalysis);
    if (mcTrg)          fDiag->Fill(kVertex,        kTrigger);
    if (mcVtx)          fDiag->Fill(kVertex,        kVertex);
    if (mcTrg && mcVtx) fDiag->Fill(kVertex,        kTriggerVertex);
  }
  if (trg && vtx) {
    fDiag->Fill(kTriggerVertex, kAnalysis);
    if (mcTrg)          fDiag->Fill(kTriggerVertex, kTrigger);
    if (mcVtx)          fDiag->Fill(kTriggerVertex, kVertex);
    if (mcTrg && mcVtx) fDiag->Fill(kTriggerVertex, kTriggerVertex);
  }
  if (primary) {
    if (mcTrg)          fDiag->Fill(kTrigger,       kMC);
    if (mcVtx)          fDiag->Fill(kVertex,        kMC);
    if (mcTrg && mcVtx) fDiag->Fill(kTriggerVertex, kMC);
  }
  if (!fIsSelected && !ok) {
    // Printf("Event is neither accepted by analysis nor by MC");
    return false; 
  }

  // forward->Print();
  // Info("", "Event vz=%f", forward->GetIpZ());
  
  ProjectX(forwardData, *fForwardCache, fUsePhiAcc);
  ProjectX(centralData, *fCentralCache, fUsePhiAcc);
  ProjectX(primary, fMCCache);
    
  TIter   next(&fBins);
  EtaBin* bin = 0;
  while ((bin = static_cast<EtaBin*>(next()))) {
    bin->Process(*fForwardCache, *fCentralCache,
		 forwardData,    centralData, 
		 fIsSelected,	 fMCCache);
  }

  return true;
}

//_____________________________________________________________________
Bool_t 
AliForwardMultDists::CheckEvent(const AliAODForwardMult& fwd)
{
  fIsSelected = AliBaseAODTask::CheckEvent(fwd);
  // We always return true, so that we can process MC truth;
  return true;
}

//____________________________________________________________________
Bool_t
AliForwardMultDists::Finalize()
{
  /*
   * Called at the end of the final processing of the job on the
   * full data set (merged data)
   */
  fResults->Add(fSums->FindObject("triggers")->Clone());
  fResults->Add(fSums->FindObject("status")->Clone());
  fResults->Add(fSums->FindObject("diagnostics")->Clone());

  THStack* sym    = new THStack("all", "All distributions");
  THStack* pos    = new THStack("all", "All distributions");
  THStack* neg    = new THStack("all", "All distributions");
  THStack* oth    = new THStack("all", "All distributions");
  THStack* sta    = 0;
  EtaBin*  bin    = 0;
  TIter    next(&fBins);
  while ((bin = static_cast<EtaBin*>(next()))) {
    bin->Terminate(fSums, fResults);

    sta = oth;
    if      (bin->IsSymmetric()) sta = sym;
    else if (bin->IsNegative())  sta = neg;
    else if (bin->IsPositive())  sta = pos;

    TH1*  hh[] = { bin->fSum, bin->fTruth, bin->fTruthAccepted, 0 };
    TH1** ph   = hh;

    Int_t idx     = sta->GetHists() ? sta->GetHists()->GetEntries() : 0;
    if (bin->fTruth) idx /= 2;
    
    Int_t mkrBits = GetIndexMarker(idx);
    while (*ph) { 
      Int_t factor = Int_t(TMath::Power(10, idx));
      TH1* h = static_cast<TH1*>((*ph)->Clone());
      h->SetDirectory(0);
      h->Scale(factor);
      h->SetTitle(Form("%s (#times%d)", h->GetTitle(), Int_t(factor)));
      h->SetMarkerStyle(GetMarkerStyle(mkrBits));
      mkrBits ^= kHollow;
      
      sta->Add(h, "p");
      ph++;
    }
  }
  TList* lsym = static_cast<TList*>(fResults->FindObject("symmetric"));
  TList* lneg = static_cast<TList*>(fResults->FindObject("negative"));
  TList* lpos = static_cast<TList*>(fResults->FindObject("positive"));
  TList* loth = static_cast<TList*>(fResults->FindObject("other"));
  
  if (lsym) lsym->Add(sym);
  if (lneg) lneg->Add(neg);
  if (lpos) lpos->Add(pos);
  if (loth) loth->Add(oth);

  return true;
}

//____________________________________________________________________
void
AliForwardMultDists::ProjectX(const TH2& input, TH1& cache, Bool_t usePhiAcc)
{
  /*
   * Project a 2D histogram into a 1D histogram taking care to use
   * either the @f$\phi@f$ acceptance stored in the overflow bins, or
   * the @f$\eta@f$ coverage stored in the underflow bins.
   * 
   * @param input      2D histogram to project 
   * @param cache      1D histogram to project into 
   * @param usePhiAcc  If true, use the @f$\phi@f$ acceptance stored in
   * the overflow bins, or if false the @f$\eta@f$ coverage stored in
   * the underflow bins.
   */
  cache.Reset();
    
  Int_t nPhi = input.GetNbinsY();
  Int_t nEta = input.GetNbinsX();

  for (Int_t iEta = 1; iEta <= nEta; iEta++) { 
    Double_t phiAcc = input.GetBinContent(iEta, nPhi+1);
    Double_t etaCov = input.GetBinContent(iEta, 0);
    Double_t factor = usePhiAcc ? phiAcc : etaCov;
      
    if (factor < 1e-3) continue; 
    Double_t sum    = 0;
    Double_t e2sum  = 0;
    for (Int_t iPhi = 1; iPhi <= nPhi; iPhi++) {
      Double_t c = input.GetBinContent(iEta, iPhi);
      Double_t e = input.GetBinError(iEta, iPhi);
	
      sum   += c;
      e2sum += e * e;
    }
    cache.SetBinContent(iEta, factor * sum);
    cache.SetBinError(iEta, factor * TMath::Sqrt(e2sum));
  }
}
//____________________________________________________________________
void
AliForwardMultDists::ProjectX(const TH2* input, TH1* cache)
{
  /*
   * Project on @f$\eta@f$ axis.  If any of the pointers passed is
   * zero, do nothing.
   * 
   * @param input 
   * @param cache 
   */
  if (!input || !cache) return;
  cache->Reset();
    
  Int_t nPhi = input->GetNbinsY();
  Int_t nEta = input->GetNbinsX();

  for (Int_t iEta = 1; iEta <= nEta; iEta++) { 
    Double_t sum    = 0;
    Double_t e2sum  = 0;
    for (Int_t iPhi = 1; iPhi <= nPhi; iPhi++) {
      Double_t c = input->GetBinContent(iEta, iPhi);
      Double_t e = input->GetBinError(iEta, iPhi);
	
      sum   += c;
      e2sum += e * e;
    }
    cache->SetBinContent(iEta, sum);
    cache->SetBinError(iEta, TMath::Sqrt(e2sum));
  }
}
//____________________________________________________________________
void
AliForwardMultDists::AddBin(const BinSpec& spec)
{
  AddBin(spec.fEtaMin, spec.fEtaMax, spec.Axis());
}

//____________________________________________________________________
void
AliForwardMultDists::AddBin(Double_t etaLow, Double_t etaMax, 
			    const TAxis& mAxis) 
{
  /*
   * Add an @f$\eta@f$ bin
   * 
   * @param etaLow Low cut on @f$\eta@f$
   * @param etaMax High cut on @f$\eta@f$
   */
  // Symmetric bin
  if (etaMax >= kInvalidEta) { 
    etaLow = -TMath::Abs(etaLow);
    etaMax = +TMath::Abs(etaLow);
  }
  EtaBin* bin = new EtaBin(etaLow, etaMax, mAxis);
  // AliInfoF("Adding bin %f, %f: %s", etaLow, etaMax, bin->GetName());
  fBins.Add(bin);
}
//____________________________________________________________________
void
AliForwardMultDists::AddBin(Double_t etaLow, Double_t etaMax, 
			    UShort_t nMax, UShort_t nDiv)
{
  /* 
   * Add an @f$\eta@f$ bin
   * 
   * @param etaLow Low cut on @f$\eta@f$
   * @param etaMax High cut on @f$\eta@f$
   */
  // Symmetric bin
  if (etaMax >= kInvalidEta) { 
    etaLow = -TMath::Abs(etaLow);
    etaMax = +TMath::Abs(etaLow);
  }
  TAxis mAxis((nMax+1)/nDiv, -.5, nMax+.5);
  EtaBin* bin = new EtaBin(etaLow, etaMax, mAxis);
  // AliInfoF("Adding bin %f, %f: %s", etaLow, etaMax, bin->GetName());
  fBins.Add(bin);
}
#define PFV(N,VALUE)					\
  do {							\
    AliForwardUtil::PrintName(N);			\
    std::cout << (VALUE) << std::endl; } while(false)
#define PFB(N,FLAG)				\
  do {									\
    AliForwardUtil::PrintName(N);					\
    std::cout << std::boolalpha << (FLAG) << std::noboolalpha << std::endl; \
  } while(false)

//____________________________________________________________________
void
AliForwardMultDists::Print(Option_t* option) const 
{
  /* 
   * Print this task 
   * 
   * @param option Not used
   */
  AliBaseAODTask::Print(option);
  gROOT->IncreaseDirLevel();
  PFB("Use phi acceptance", fUsePhiAcc);
  // AliForwardUtil::PrintName("Bins");

  Int_t first = true;
  TIter   next(&fBins);
  EtaBin* bin = 0;
  while ((bin = static_cast<EtaBin*>(next()))) {
    PFV(first ? "Bins" : "", bin->GetName());
    first = false;
  }
  gROOT->DecreaseDirLevel();
}

//====================================================================
AliForwardMultDists::EtaBin::EtaBin() 
  : fName(""),
    fMAxis(1,0,0),
    fTAxis(1,0,0),
    fMinEta(0),
    fMaxEta(0),
    fMinBin(0), 
    fMaxBin(0), 
    fSum(0),
    fCorr(0),
    fResponse(0), 
    fTruth(0),
    fTruthAccepted(0),
    fCoverage(0)
{
  /* 
   * I/O constructor
   */
}

//____________________________________________________________________
AliForwardMultDists::EtaBin::EtaBin(Double_t minEta, Double_t maxEta,
				    const TAxis& mAxis) 
  : fName(""),
    fMAxis(1,0,0),
    fTAxis(1,0,0),
    fMinEta(minEta), 
    fMaxEta(maxEta),
    fMinBin(0), 
    fMaxBin(0), 
    fSum(0),
    fCorr(0),
    fResponse(0), 
    fTruth(0),
    fTruthAccepted(0),
    fCoverage(0)
{
  /*
   * User constructor 
   * 
   * @param minEta Least @f$\eta@f$ to consider 
   * @param maxEta Largest @f$\eta@f$ to consider 
   */
  fName = TString::Format("%+05.2f_%+05.2f", fMinEta, fMaxEta);
  fName.ReplaceAll("-", "m");
  fName.ReplaceAll("+", "p");
  fName.ReplaceAll(".", "d");

  // Copy to other our object
  mAxis.Copy(fMAxis);
  
  if (mAxis.GetXbins() && mAxis.GetXbins()->GetArray()) {
    const TArrayD& mA  = *(mAxis.GetXbins());
    TArrayD        tA(mA.GetSize());
    Int_t          j   = 0;
    Double_t       min = mA[0];
    tA[0]              = min;
    for (Int_t i = 1; i < mA.GetSize(); i++) { 
      Double_t d = mA[i] - min;
      if (d < 1) 
	// Not full integer bin
	continue;  
      tA[j+1] = tA[j] + Int_t(d);
      min     = tA[j+1];
      j++;
    }
    fTAxis.Set(j, tA.GetArray());
  }
  else {
    // Rounded down maximum and minimum
    Int_t max = Int_t(mAxis.GetXmax()); 
    Int_t min = Int_t(mAxis.GetXmin());
    fTAxis.Set((max-min)+1, min-.5, max+.5);
  }
}
//____________________________________________________________________
AliForwardMultDists::EtaBin::EtaBin(const EtaBin& o) 
  : TObject(o),
    fName(o.fName),
    fMAxis(o.fMAxis), 
    fTAxis(o.fTAxis),
    fMinEta(o.fMinEta),
    fMaxEta(o.fMaxEta),
    fMinBin(o.fMinBin), 
    fMaxBin(o.fMaxBin), 
    fSum(o.fSum),
    fCorr(o.fCorr),
    fResponse(o.fResponse), 
    fTruth(o.fTruth),
    fTruthAccepted(o.fTruthAccepted),
    fCoverage(o.fCoverage)
{}
//____________________________________________________________________
AliForwardMultDists::EtaBin&
AliForwardMultDists::EtaBin::operator=(const EtaBin& o) 
{
  if (&o == this) return *this;
  
  fName		 = o.fName;
  fMAxis         = o.fMAxis;
  fTAxis         = o.fTAxis;
  fMinEta	 = o.fMinEta;
  fMaxEta	 = o.fMaxEta;
  fMinBin	 = o.fMinBin; 
  fMaxBin	 = o.fMaxBin; 
  fSum		 = o.fSum;
  fCorr		 = o.fCorr;
  fResponse	 = o.fResponse; 
  fTruth	 = o.fTruth;
  fTruthAccepted = o.fTruthAccepted;
  fCoverage      = o.fCoverage;

  return *this;
}
//____________________________________________________________________
Bool_t
AliForwardMultDists::EtaBin::IsSymmetric() const
{
  return TMath::Abs(fMaxEta + fMinEta) < 1e-6;
}
//____________________________________________________________________
Bool_t
AliForwardMultDists::EtaBin::IsNegative() const
{
  return TMath::Abs(fMaxEta) < 1e-6 && fMinEta < 0;
}
//____________________________________________________________________
Bool_t
AliForwardMultDists::EtaBin::IsPositive() const
{
  return TMath::Abs(fMinEta) < 1e-6 && fMaxEta > 0;
}
//____________________________________________________________________
const char*
AliForwardMultDists::EtaBin::ParentName() const
{
  if      (IsSymmetric()) return "symmetric";
  else if (IsNegative())  return "negative";
  else if (IsPositive())  return "positive";
  return "other";
}
//____________________________________________________________________
TList*
AliForwardMultDists::EtaBin::FindParent(TList* l, Bool_t create) const
{
  const char* parent = ParentName();
  TObject*    op     = l->FindObject(parent);

  if (op) return static_cast<TList*>(op);
  if (!create) return 0;

  // Info("FindParent", "Parent %s not found in %s, creating and adding",
  //      parent, l->GetName());
  TList* p = new TList;
  p->SetName(parent);
  p->SetOwner();
  l->Add(p);

  TList* lowEdges = new TList;
  lowEdges->SetName("lowEdges");
  lowEdges->SetOwner();
  p->Add(lowEdges);

  TList* highEdges = new TList;
  highEdges->SetName("highEdges");
  highEdges->SetOwner();
  p->Add(highEdges);
  
  return p;
}

//____________________________________________________________________
TH1*
AliForwardMultDists::EtaBin::CreateH1(const char*  name, 
				      const char*  title, 
				      const TAxis& xAxis)
{
  TH1* ret = 0;
  
  if (xAxis.GetXbins() && xAxis.GetXbins()->GetArray()) 
    ret = new TH1D(name,title,xAxis.GetNbins(), xAxis.GetXbins()->GetArray());
  else 
    ret = new TH1D(name,title,xAxis.GetNbins(),xAxis.GetXmin(),xAxis.GetXmax());
  return ret;
}
//____________________________________________________________________
TH2*
AliForwardMultDists::EtaBin::CreateH2(const char*  name, 
				      const char*  title, 
				      const TAxis& xAxis,
				      const TAxis& yAxis)
{
  TH2* ret = 0;
  
  if (xAxis.GetXbins() && xAxis.GetXbins()->GetArray()) {
    if (yAxis.GetXbins() && yAxis.GetXbins()->GetArray()) 
      // Variable variable
      ret = new TH2D(name,title, 
		     xAxis.GetNbins(), xAxis.GetXbins()->GetArray(),
		     yAxis.GetNbins(), yAxis.GetXbins()->GetArray());
    else 
      // variable fixed
      ret = new TH2D(name,title, 
		     xAxis.GetNbins(), xAxis.GetXbins()->GetArray(),
		     yAxis.GetNbins(),yAxis.GetXmin(),yAxis.GetXmax());
  }
  else {
    if (yAxis.GetXbins() && yAxis.GetXbins()->GetArray()) 
      // fixed variable 
      ret = new TH2D(name,title, 
		     xAxis.GetNbins(), xAxis.GetXmin(), xAxis.GetXmax(),
		     yAxis.GetNbins(), yAxis.GetXbins()->GetArray());
    else 
      // fixed fixed
      ret = new TH2D(name,title, 
		     xAxis.GetNbins(), xAxis.GetXmin(), xAxis.GetXmax(),
		     yAxis.GetNbins(), yAxis.GetXmin(), yAxis.GetXmax());
  }
  return ret;
}

//____________________________________________________________________
void
AliForwardMultDists::EtaBin::SetupForData(TList* list, const TH2& hist, 
					  Bool_t useMC)
{
  /*
   * Set-up internal structures on first event. 
   * 
   * @param list  List to add information to
   * @param hist  Template histogram 
   * @param max   Maximum number of particles 
   * @param useMC Whether to set-up for MC input 
   */
  TList* p = FindParent(list, true);
  TList* l = new TList;
  l->SetName(GetName());
  l->SetOwner();
  p->Add(l);
  TList* le = static_cast<TList*>(p->FindObject("lowEdges"));
  TList* he = static_cast<TList*>(p->FindObject("highEdges"));
  if (!le || !he) { 
    AliError("Failed to get bin edge lists from parent");
    return;
  }
  else {
    Int_t n = le->GetEntries();
    TParameter<double>* lp = 
      new TParameter<double>(Form("minEta%02d", n), fMinEta);
    TParameter<double>* hp = 
      new TParameter<double>(Form("maxEta%02d", n), fMaxEta);
    lp->SetMergeMode('f');
    hp->SetMergeMode('f');
    le->Add(lp);
    he->Add(hp);
  }

  const TAxis * xax = hist.GetXaxis();
  fMinBin = xax->FindFixBin(fMinEta);
  fMaxBin = xax->FindFixBin(fMaxEta-.00001);

  TString t(Form("%+5.2f<#eta<%+5.2f", fMinEta, fMaxEta));
  fSum = CreateH1("rawDist",Form("Raw P(#it{N}_{ch}) in %s",t.Data()),fMAxis);
  fSum->SetDirectory(0);
  fSum->GetXaxis()->SetTitle("#it{N}_{ch}");
  fSum->GetYaxis()->SetTitle("Raw P(#it{N}_{ch})");
  fSum->SetFillColor(kRed+1);
  fSum->SetFillStyle(0);
  // fSum->SetOption("hist e");
  fSum->SetMarkerStyle(20);
  fSum->SetMarkerColor(kRed+1);
  fSum->SetLineColor(kBlack);
  fSum->Sumw2();
  l->Add(fSum);
  
  fCorr = CreateH2("corr",Form("C_{SPD,FMD} in %s", t.Data()),fTAxis,fTAxis);
  fCorr->SetDirectory(0);
  fCorr->GetXaxis()->SetTitle("Forward");
  fCorr->GetYaxis()->SetTitle("Central");
  fCorr->SetOption("colz");
  l->Add(fCorr);

  fCoverage = new TH1D("coverage", "Fraction of bins with coverage",
		       101, -.5, 100.5);
  fCoverage->SetDirectory(0);
  fCoverage->SetXTitle("Fraction of bins [%]");
  fCoverage->SetFillStyle(3001);
  fCoverage->SetFillColor(kGreen+1);
  l->Add(fCoverage);

  if (!useMC) return;
  fResponse = CreateH2("response", Form("Reponse matrix in %s", t.Data()),
		       fMAxis, fTAxis);
  fResponse->SetDirectory(0);
  fResponse->SetYTitle("MC");
  fResponse->SetXTitle("Signal");
  fResponse->SetOption("colz");
  l->Add(fResponse);
  
  fTruth = CreateH1("truth",Form("True P(#it{N}_{ch}) in %s",t.Data()),fTAxis);
  fTruth->SetXTitle(fSum->GetXaxis()->GetTitle());
  fTruth->SetYTitle(fSum->GetYaxis()->GetTitle());
  fTruth->SetLineColor(kBlack);
  fTruth->SetFillColor(kBlue+1);
  fTruth->SetFillStyle(0);
  fTruth->SetDirectory(0);
  /// fTruth->SetOption("");
  fTruth->SetMarkerColor(kBlue+1);
  fTruth->SetMarkerStyle(24);
  fTruth->Sumw2();
  l->Add(fTruth);

  fTruthAccepted = static_cast<TH1D*>(fTruth->Clone("truthAccepted"));
  fTruthAccepted->SetTitle(Form("True (accepted) P(#it{N}_{ch}) in %s", 
				t.Data()));
  fTruthAccepted->SetLineColor(kGray+2);
  fTruthAccepted->SetFillColor(kOrange+2);
  fTruthAccepted->SetDirectory(0);
  /// fTruth->SetOption("");
  fTruthAccepted->SetMarkerColor(kOrange+2);
  l->Add(fTruthAccepted);
}
//____________________________________________________________________
void
AliForwardMultDists::EtaBin::Process(const TH1& sumForward, 
				     const TH1& sumCentral,
				     const TH2& forward,   
				     const TH2& central,
				     Bool_t     accepted, 
				     const TH1* mc)
{
  /*
   * Process a single event 
   * 
   * @param sumForward  Projection of forward data
   * @param sumCentral  Projection of the central data
   * @param forward     The original forward data 
   * @param central     The original central data
   */
  if (!mc && !accepted) 
    // If we're not looking at MC data, and the event wasn't selected,
    // we bail out - this check is already done, but we do it again
    // for safety.
    return;

  Double_t sum        = 0;
  Double_t e2sum      = 0;
  Int_t    covered    = 0;
  Double_t fsum       = -1;
  Double_t csum       = -1;
  Double_t mcsum      = 0;
  Double_t mce2sum    = 0;
  for (Int_t iEta = fMinBin; iEta <= fMaxBin; iEta++) { 
    if (mc) {
      Double_t cM = mc->GetBinContent(iEta);
      Double_t eM = mc->GetBinError(iEta);
      mcsum   += cM;
      mce2sum += eM * eM;
    }
    if (!accepted) 
      // Event wasn't selected, but we still need to get the rest of
      // the MC data.
      continue;

    Double_t cF = sumForward.GetBinContent(iEta);
    Double_t eF = sumForward.GetBinError(iEta);
    Bool_t   bF = forward.GetBinContent(iEta, 0) > 0;
    Double_t cC = sumCentral.GetBinContent(iEta);
    Double_t eC = sumCentral.GetBinError(iEta);
    Bool_t   bC = central.GetBinContent(iEta, 0) > 0;
    Double_t c  = 0;
    Double_t e  = 0;

    // If we have an overlap - as given by the eta-coverage, 
    // calculate the mean 
    if (bF & bC) { 
      c = (cF + cC) / 2;
      e = TMath::Sqrt(eF*eF + eC*eC);
      covered++;
    }
    // Else, if we have coverage from forward, use that 
    else if (bF) { 
      c = cF;
      e = eF;
      covered++;
    }
    // Else, if we have covrage from central, use that 
    else if (bC) { 
      c = cC;
      e = eC;
      covered++;
    }
    // Else, we have incomplete coverage 

    if (bF) { 
      if (fsum < 0) fsum = 0;
      fsum += cF;
    }
    if (bC) { 
      if (csum < 0) csum = 0;
      csum += cC;
    }
	
    sum   += c;
    e2sum += e*e;
  }
      
  if (accepted) {
    // Only update the histograms if the event was triggered. 
    // Fill with weight 
    Double_t w = 1; // e2sum > 0 ? 1/TMath::Sqrt(e2sum) : 1
    fSum->Fill(sum, w);
    fCorr->Fill((fsum<0?0:fsum), (csum<0?0:csum));
    
    Int_t nTotal = fMaxBin - fMinBin + 1;
    fCoverage->Fill(100*float(covered) / nTotal);
  }

  if (mc) {
    Double_t w = 1; // mce2sum > 0 ? 1/TMath::Sqrt(mce2sum) : 1
    if (fTruth) {
      fTruth->Fill(mcsum, w);
    }
    if (accepted) {
      if (fResponse) 
	// Only fill response matrix for accepted events
	fResponse->Fill(sum, mcsum);
      if (fTruthAccepted) 
	fTruthAccepted->Fill(mcsum, w);
    }
  }
}
//____________________________________________________________________
void
AliForwardMultDists::EtaBin::Terminate(TList* in, TList* out)
{
  /*
   * Called at the end of the final processing of the job on the
   * full data set (merged data)
   * 
   * @param in    Input list
   * @param out   Output list 
   * @param maxN  Maximum number of @f$N_{ch}@f$ to consider
   */
  TList* ip = FindParent(in, false);
  if (!ip) { 
    AliErrorF("Parent folder %s not found in input", ParentName());
    return;
  }

  TList* i = dynamic_cast<TList*>(ip->FindObject(GetName()));
  if (!i) { 
    AliErrorF("List %s not found in input", GetName());
    return;
  }
      
  TList* op = FindParent(out, true);
  TList* o  = static_cast<TList*>(i->Clone());
  o->SetOwner();
  op->Add(o);

  fSum           = static_cast<TH1*>(o->FindObject("rawDist"));
  fTruth         = static_cast<TH1*>(o->FindObject("truth"));
  fTruthAccepted = static_cast<TH1*>(o->FindObject("truthAccepted"));

  TH1*  hists[] = { fSum, fTruth, fTruthAccepted, 0 };
  TH1** phist   = hists;
  while (*phist) { 
    TH1* h = *phist;
    if (h) { 
      Int_t    maxN = h->GetNbinsX();
      Double_t intg = h->Integral(1, maxN);
      h->Scale(1. / intg, "width");
    }
    phist++;
  }

  if (fTruth && fTruthAccepted) {
    TH1*  trgVtx  = static_cast<TH1*>(fTruthAccepted->Clone("triggerVertex"));
    TString tit(fTruth->GetTitle());
    tit.ReplaceAll("True P(#it{N}_{ch})", "C_{trigger,vertex}");
    trgVtx->SetTitle(tit);
    trgVtx->SetYTitle("P_{MC}(#it{N}_{ch})/P_{MC,accepted}(#it{N}_{ch})");
    trgVtx->Divide(fTruth);
    trgVtx->SetDirectory(0);
    o->Add(trgVtx);
  }
  
}
//====================================================================
// 
// EOF
//
 AliForwardMultDists.cxx:1
 AliForwardMultDists.cxx:2
 AliForwardMultDists.cxx:3
 AliForwardMultDists.cxx:4
 AliForwardMultDists.cxx:5
 AliForwardMultDists.cxx:6
 AliForwardMultDists.cxx:7
 AliForwardMultDists.cxx:8
 AliForwardMultDists.cxx:9
 AliForwardMultDists.cxx:10
 AliForwardMultDists.cxx:11
 AliForwardMultDists.cxx:12
 AliForwardMultDists.cxx:13
 AliForwardMultDists.cxx:14
 AliForwardMultDists.cxx:15
 AliForwardMultDists.cxx:16
 AliForwardMultDists.cxx:17
 AliForwardMultDists.cxx:18
 AliForwardMultDists.cxx:19
 AliForwardMultDists.cxx:20
 AliForwardMultDists.cxx:21
 AliForwardMultDists.cxx:22
 AliForwardMultDists.cxx:23
 AliForwardMultDists.cxx:24
 AliForwardMultDists.cxx:25
 AliForwardMultDists.cxx:26
 AliForwardMultDists.cxx:27
 AliForwardMultDists.cxx:28
 AliForwardMultDists.cxx:29
 AliForwardMultDists.cxx:30
 AliForwardMultDists.cxx:31
 AliForwardMultDists.cxx:32
 AliForwardMultDists.cxx:33
 AliForwardMultDists.cxx:34
 AliForwardMultDists.cxx:35
 AliForwardMultDists.cxx:36
 AliForwardMultDists.cxx:37
 AliForwardMultDists.cxx:38
 AliForwardMultDists.cxx:39
 AliForwardMultDists.cxx:40
 AliForwardMultDists.cxx:41
 AliForwardMultDists.cxx:42
 AliForwardMultDists.cxx:43
 AliForwardMultDists.cxx:44
 AliForwardMultDists.cxx:45
 AliForwardMultDists.cxx:46
 AliForwardMultDists.cxx:47
 AliForwardMultDists.cxx:48
 AliForwardMultDists.cxx:49
 AliForwardMultDists.cxx:50
 AliForwardMultDists.cxx:51
 AliForwardMultDists.cxx:52
 AliForwardMultDists.cxx:53
 AliForwardMultDists.cxx:54
 AliForwardMultDists.cxx:55
 AliForwardMultDists.cxx:56
 AliForwardMultDists.cxx:57
 AliForwardMultDists.cxx:58
 AliForwardMultDists.cxx:59
 AliForwardMultDists.cxx:60
 AliForwardMultDists.cxx:61
 AliForwardMultDists.cxx:62
 AliForwardMultDists.cxx:63
 AliForwardMultDists.cxx:64
 AliForwardMultDists.cxx:65
 AliForwardMultDists.cxx:66
 AliForwardMultDists.cxx:67
 AliForwardMultDists.cxx:68
 AliForwardMultDists.cxx:69
 AliForwardMultDists.cxx:70
 AliForwardMultDists.cxx:71
 AliForwardMultDists.cxx:72
 AliForwardMultDists.cxx:73
 AliForwardMultDists.cxx:74
 AliForwardMultDists.cxx:75
 AliForwardMultDists.cxx:76
 AliForwardMultDists.cxx:77
 AliForwardMultDists.cxx:78
 AliForwardMultDists.cxx:79
 AliForwardMultDists.cxx:80
 AliForwardMultDists.cxx:81
 AliForwardMultDists.cxx:82
 AliForwardMultDists.cxx:83
 AliForwardMultDists.cxx:84
 AliForwardMultDists.cxx:85
 AliForwardMultDists.cxx:86
 AliForwardMultDists.cxx:87
 AliForwardMultDists.cxx:88
 AliForwardMultDists.cxx:89
 AliForwardMultDists.cxx:90
 AliForwardMultDists.cxx:91
 AliForwardMultDists.cxx:92
 AliForwardMultDists.cxx:93
 AliForwardMultDists.cxx:94
 AliForwardMultDists.cxx:95
 AliForwardMultDists.cxx:96
 AliForwardMultDists.cxx:97
 AliForwardMultDists.cxx:98
 AliForwardMultDists.cxx:99
 AliForwardMultDists.cxx:100
 AliForwardMultDists.cxx:101
 AliForwardMultDists.cxx:102
 AliForwardMultDists.cxx:103
 AliForwardMultDists.cxx:104
 AliForwardMultDists.cxx:105
 AliForwardMultDists.cxx:106
 AliForwardMultDists.cxx:107
 AliForwardMultDists.cxx:108
 AliForwardMultDists.cxx:109
 AliForwardMultDists.cxx:110
 AliForwardMultDists.cxx:111
 AliForwardMultDists.cxx:112
 AliForwardMultDists.cxx:113
 AliForwardMultDists.cxx:114
 AliForwardMultDists.cxx:115
 AliForwardMultDists.cxx:116
 AliForwardMultDists.cxx:117
 AliForwardMultDists.cxx:118
 AliForwardMultDists.cxx:119
 AliForwardMultDists.cxx:120
 AliForwardMultDists.cxx:121
 AliForwardMultDists.cxx:122
 AliForwardMultDists.cxx:123
 AliForwardMultDists.cxx:124
 AliForwardMultDists.cxx:125
 AliForwardMultDists.cxx:126
 AliForwardMultDists.cxx:127
 AliForwardMultDists.cxx:128
 AliForwardMultDists.cxx:129
 AliForwardMultDists.cxx:130
 AliForwardMultDists.cxx:131
 AliForwardMultDists.cxx:132
 AliForwardMultDists.cxx:133
 AliForwardMultDists.cxx:134
 AliForwardMultDists.cxx:135
 AliForwardMultDists.cxx:136
 AliForwardMultDists.cxx:137
 AliForwardMultDists.cxx:138
 AliForwardMultDists.cxx:139
 AliForwardMultDists.cxx:140
 AliForwardMultDists.cxx:141
 AliForwardMultDists.cxx:142
 AliForwardMultDists.cxx:143
 AliForwardMultDists.cxx:144
 AliForwardMultDists.cxx:145
 AliForwardMultDists.cxx:146
 AliForwardMultDists.cxx:147
 AliForwardMultDists.cxx:148
 AliForwardMultDists.cxx:149
 AliForwardMultDists.cxx:150
 AliForwardMultDists.cxx:151
 AliForwardMultDists.cxx:152
 AliForwardMultDists.cxx:153
 AliForwardMultDists.cxx:154
 AliForwardMultDists.cxx:155
 AliForwardMultDists.cxx:156
 AliForwardMultDists.cxx:157
 AliForwardMultDists.cxx:158
 AliForwardMultDists.cxx:159
 AliForwardMultDists.cxx:160
 AliForwardMultDists.cxx:161
 AliForwardMultDists.cxx:162
 AliForwardMultDists.cxx:163
 AliForwardMultDists.cxx:164
 AliForwardMultDists.cxx:165
 AliForwardMultDists.cxx:166
 AliForwardMultDists.cxx:167
 AliForwardMultDists.cxx:168
 AliForwardMultDists.cxx:169
 AliForwardMultDists.cxx:170
 AliForwardMultDists.cxx:171
 AliForwardMultDists.cxx:172
 AliForwardMultDists.cxx:173
 AliForwardMultDists.cxx:174
 AliForwardMultDists.cxx:175
 AliForwardMultDists.cxx:176
 AliForwardMultDists.cxx:177
 AliForwardMultDists.cxx:178
 AliForwardMultDists.cxx:179
 AliForwardMultDists.cxx:180
 AliForwardMultDists.cxx:181
 AliForwardMultDists.cxx:182
 AliForwardMultDists.cxx:183
 AliForwardMultDists.cxx:184
 AliForwardMultDists.cxx:185
 AliForwardMultDists.cxx:186
 AliForwardMultDists.cxx:187
 AliForwardMultDists.cxx:188
 AliForwardMultDists.cxx:189
 AliForwardMultDists.cxx:190
 AliForwardMultDists.cxx:191
 AliForwardMultDists.cxx:192
 AliForwardMultDists.cxx:193
 AliForwardMultDists.cxx:194
 AliForwardMultDists.cxx:195
 AliForwardMultDists.cxx:196
 AliForwardMultDists.cxx:197
 AliForwardMultDists.cxx:198
 AliForwardMultDists.cxx:199
 AliForwardMultDists.cxx:200
 AliForwardMultDists.cxx:201
 AliForwardMultDists.cxx:202
 AliForwardMultDists.cxx:203
 AliForwardMultDists.cxx:204
 AliForwardMultDists.cxx:205
 AliForwardMultDists.cxx:206
 AliForwardMultDists.cxx:207
 AliForwardMultDists.cxx:208
 AliForwardMultDists.cxx:209
 AliForwardMultDists.cxx:210
 AliForwardMultDists.cxx:211
 AliForwardMultDists.cxx:212
 AliForwardMultDists.cxx:213
 AliForwardMultDists.cxx:214
 AliForwardMultDists.cxx:215
 AliForwardMultDists.cxx:216
 AliForwardMultDists.cxx:217
 AliForwardMultDists.cxx:218
 AliForwardMultDists.cxx:219
 AliForwardMultDists.cxx:220
 AliForwardMultDists.cxx:221
 AliForwardMultDists.cxx:222
 AliForwardMultDists.cxx:223
 AliForwardMultDists.cxx:224
 AliForwardMultDists.cxx:225
 AliForwardMultDists.cxx:226
 AliForwardMultDists.cxx:227
 AliForwardMultDists.cxx:228
 AliForwardMultDists.cxx:229
 AliForwardMultDists.cxx:230
 AliForwardMultDists.cxx:231
 AliForwardMultDists.cxx:232
 AliForwardMultDists.cxx:233
 AliForwardMultDists.cxx:234
 AliForwardMultDists.cxx:235
 AliForwardMultDists.cxx:236
 AliForwardMultDists.cxx:237
 AliForwardMultDists.cxx:238
 AliForwardMultDists.cxx:239
 AliForwardMultDists.cxx:240
 AliForwardMultDists.cxx:241
 AliForwardMultDists.cxx:242
 AliForwardMultDists.cxx:243
 AliForwardMultDists.cxx:244
 AliForwardMultDists.cxx:245
 AliForwardMultDists.cxx:246
 AliForwardMultDists.cxx:247
 AliForwardMultDists.cxx:248
 AliForwardMultDists.cxx:249
 AliForwardMultDists.cxx:250
 AliForwardMultDists.cxx:251
 AliForwardMultDists.cxx:252
 AliForwardMultDists.cxx:253
 AliForwardMultDists.cxx:254
 AliForwardMultDists.cxx:255
 AliForwardMultDists.cxx:256
 AliForwardMultDists.cxx:257
 AliForwardMultDists.cxx:258
 AliForwardMultDists.cxx:259
 AliForwardMultDists.cxx:260
 AliForwardMultDists.cxx:261
 AliForwardMultDists.cxx:262
 AliForwardMultDists.cxx:263
 AliForwardMultDists.cxx:264
 AliForwardMultDists.cxx:265
 AliForwardMultDists.cxx:266
 AliForwardMultDists.cxx:267
 AliForwardMultDists.cxx:268
 AliForwardMultDists.cxx:269
 AliForwardMultDists.cxx:270
 AliForwardMultDists.cxx:271
 AliForwardMultDists.cxx:272
 AliForwardMultDists.cxx:273
 AliForwardMultDists.cxx:274
 AliForwardMultDists.cxx:275
 AliForwardMultDists.cxx:276
 AliForwardMultDists.cxx:277
 AliForwardMultDists.cxx:278
 AliForwardMultDists.cxx:279
 AliForwardMultDists.cxx:280
 AliForwardMultDists.cxx:281
 AliForwardMultDists.cxx:282
 AliForwardMultDists.cxx:283
 AliForwardMultDists.cxx:284
 AliForwardMultDists.cxx:285
 AliForwardMultDists.cxx:286
 AliForwardMultDists.cxx:287
 AliForwardMultDists.cxx:288
 AliForwardMultDists.cxx:289
 AliForwardMultDists.cxx:290
 AliForwardMultDists.cxx:291
 AliForwardMultDists.cxx:292
 AliForwardMultDists.cxx:293
 AliForwardMultDists.cxx:294
 AliForwardMultDists.cxx:295
 AliForwardMultDists.cxx:296
 AliForwardMultDists.cxx:297
 AliForwardMultDists.cxx:298
 AliForwardMultDists.cxx:299
 AliForwardMultDists.cxx:300
 AliForwardMultDists.cxx:301
 AliForwardMultDists.cxx:302
 AliForwardMultDists.cxx:303
 AliForwardMultDists.cxx:304
 AliForwardMultDists.cxx:305
 AliForwardMultDists.cxx:306
 AliForwardMultDists.cxx:307
 AliForwardMultDists.cxx:308
 AliForwardMultDists.cxx:309
 AliForwardMultDists.cxx:310
 AliForwardMultDists.cxx:311
 AliForwardMultDists.cxx:312
 AliForwardMultDists.cxx:313
 AliForwardMultDists.cxx:314
 AliForwardMultDists.cxx:315
 AliForwardMultDists.cxx:316
 AliForwardMultDists.cxx:317
 AliForwardMultDists.cxx:318
 AliForwardMultDists.cxx:319
 AliForwardMultDists.cxx:320
 AliForwardMultDists.cxx:321
 AliForwardMultDists.cxx:322
 AliForwardMultDists.cxx:323
 AliForwardMultDists.cxx:324
 AliForwardMultDists.cxx:325
 AliForwardMultDists.cxx:326
 AliForwardMultDists.cxx:327
 AliForwardMultDists.cxx:328
 AliForwardMultDists.cxx:329
 AliForwardMultDists.cxx:330
 AliForwardMultDists.cxx:331
 AliForwardMultDists.cxx:332
 AliForwardMultDists.cxx:333
 AliForwardMultDists.cxx:334
 AliForwardMultDists.cxx:335
 AliForwardMultDists.cxx:336
 AliForwardMultDists.cxx:337
 AliForwardMultDists.cxx:338
 AliForwardMultDists.cxx:339
 AliForwardMultDists.cxx:340
 AliForwardMultDists.cxx:341
 AliForwardMultDists.cxx:342
 AliForwardMultDists.cxx:343
 AliForwardMultDists.cxx:344
 AliForwardMultDists.cxx:345
 AliForwardMultDists.cxx:346
 AliForwardMultDists.cxx:347
 AliForwardMultDists.cxx:348
 AliForwardMultDists.cxx:349
 AliForwardMultDists.cxx:350
 AliForwardMultDists.cxx:351
 AliForwardMultDists.cxx:352
 AliForwardMultDists.cxx:353
 AliForwardMultDists.cxx:354
 AliForwardMultDists.cxx:355
 AliForwardMultDists.cxx:356
 AliForwardMultDists.cxx:357
 AliForwardMultDists.cxx:358
 AliForwardMultDists.cxx:359
 AliForwardMultDists.cxx:360
 AliForwardMultDists.cxx:361
 AliForwardMultDists.cxx:362
 AliForwardMultDists.cxx:363
 AliForwardMultDists.cxx:364
 AliForwardMultDists.cxx:365
 AliForwardMultDists.cxx:366
 AliForwardMultDists.cxx:367
 AliForwardMultDists.cxx:368
 AliForwardMultDists.cxx:369
 AliForwardMultDists.cxx:370
 AliForwardMultDists.cxx:371
 AliForwardMultDists.cxx:372
 AliForwardMultDists.cxx:373
 AliForwardMultDists.cxx:374
 AliForwardMultDists.cxx:375
 AliForwardMultDists.cxx:376
 AliForwardMultDists.cxx:377
 AliForwardMultDists.cxx:378
 AliForwardMultDists.cxx:379
 AliForwardMultDists.cxx:380
 AliForwardMultDists.cxx:381
 AliForwardMultDists.cxx:382
 AliForwardMultDists.cxx:383
 AliForwardMultDists.cxx:384
 AliForwardMultDists.cxx:385
 AliForwardMultDists.cxx:386
 AliForwardMultDists.cxx:387
 AliForwardMultDists.cxx:388
 AliForwardMultDists.cxx:389
 AliForwardMultDists.cxx:390
 AliForwardMultDists.cxx:391
 AliForwardMultDists.cxx:392
 AliForwardMultDists.cxx:393
 AliForwardMultDists.cxx:394
 AliForwardMultDists.cxx:395
 AliForwardMultDists.cxx:396
 AliForwardMultDists.cxx:397
 AliForwardMultDists.cxx:398
 AliForwardMultDists.cxx:399
 AliForwardMultDists.cxx:400
 AliForwardMultDists.cxx:401
 AliForwardMultDists.cxx:402
 AliForwardMultDists.cxx:403
 AliForwardMultDists.cxx:404
 AliForwardMultDists.cxx:405
 AliForwardMultDists.cxx:406
 AliForwardMultDists.cxx:407
 AliForwardMultDists.cxx:408
 AliForwardMultDists.cxx:409
 AliForwardMultDists.cxx:410
 AliForwardMultDists.cxx:411
 AliForwardMultDists.cxx:412
 AliForwardMultDists.cxx:413
 AliForwardMultDists.cxx:414
 AliForwardMultDists.cxx:415
 AliForwardMultDists.cxx:416
 AliForwardMultDists.cxx:417
 AliForwardMultDists.cxx:418
 AliForwardMultDists.cxx:419
 AliForwardMultDists.cxx:420
 AliForwardMultDists.cxx:421
 AliForwardMultDists.cxx:422
 AliForwardMultDists.cxx:423
 AliForwardMultDists.cxx:424
 AliForwardMultDists.cxx:425
 AliForwardMultDists.cxx:426
 AliForwardMultDists.cxx:427
 AliForwardMultDists.cxx:428
 AliForwardMultDists.cxx:429
 AliForwardMultDists.cxx:430
 AliForwardMultDists.cxx:431
 AliForwardMultDists.cxx:432
 AliForwardMultDists.cxx:433
 AliForwardMultDists.cxx:434
 AliForwardMultDists.cxx:435
 AliForwardMultDists.cxx:436
 AliForwardMultDists.cxx:437
 AliForwardMultDists.cxx:438
 AliForwardMultDists.cxx:439
 AliForwardMultDists.cxx:440
 AliForwardMultDists.cxx:441
 AliForwardMultDists.cxx:442
 AliForwardMultDists.cxx:443
 AliForwardMultDists.cxx:444
 AliForwardMultDists.cxx:445
 AliForwardMultDists.cxx:446
 AliForwardMultDists.cxx:447
 AliForwardMultDists.cxx:448
 AliForwardMultDists.cxx:449
 AliForwardMultDists.cxx:450
 AliForwardMultDists.cxx:451
 AliForwardMultDists.cxx:452
 AliForwardMultDists.cxx:453
 AliForwardMultDists.cxx:454
 AliForwardMultDists.cxx:455
 AliForwardMultDists.cxx:456
 AliForwardMultDists.cxx:457
 AliForwardMultDists.cxx:458
 AliForwardMultDists.cxx:459
 AliForwardMultDists.cxx:460
 AliForwardMultDists.cxx:461
 AliForwardMultDists.cxx:462
 AliForwardMultDists.cxx:463
 AliForwardMultDists.cxx:464
 AliForwardMultDists.cxx:465
 AliForwardMultDists.cxx:466
 AliForwardMultDists.cxx:467
 AliForwardMultDists.cxx:468
 AliForwardMultDists.cxx:469
 AliForwardMultDists.cxx:470
 AliForwardMultDists.cxx:471
 AliForwardMultDists.cxx:472
 AliForwardMultDists.cxx:473
 AliForwardMultDists.cxx:474
 AliForwardMultDists.cxx:475
 AliForwardMultDists.cxx:476
 AliForwardMultDists.cxx:477
 AliForwardMultDists.cxx:478
 AliForwardMultDists.cxx:479
 AliForwardMultDists.cxx:480
 AliForwardMultDists.cxx:481
 AliForwardMultDists.cxx:482
 AliForwardMultDists.cxx:483
 AliForwardMultDists.cxx:484
 AliForwardMultDists.cxx:485
 AliForwardMultDists.cxx:486
 AliForwardMultDists.cxx:487
 AliForwardMultDists.cxx:488
 AliForwardMultDists.cxx:489
 AliForwardMultDists.cxx:490
 AliForwardMultDists.cxx:491
 AliForwardMultDists.cxx:492
 AliForwardMultDists.cxx:493
 AliForwardMultDists.cxx:494
 AliForwardMultDists.cxx:495
 AliForwardMultDists.cxx:496
 AliForwardMultDists.cxx:497
 AliForwardMultDists.cxx:498
 AliForwardMultDists.cxx:499
 AliForwardMultDists.cxx:500
 AliForwardMultDists.cxx:501
 AliForwardMultDists.cxx:502
 AliForwardMultDists.cxx:503
 AliForwardMultDists.cxx:504
 AliForwardMultDists.cxx:505
 AliForwardMultDists.cxx:506
 AliForwardMultDists.cxx:507
 AliForwardMultDists.cxx:508
 AliForwardMultDists.cxx:509
 AliForwardMultDists.cxx:510
 AliForwardMultDists.cxx:511
 AliForwardMultDists.cxx:512
 AliForwardMultDists.cxx:513
 AliForwardMultDists.cxx:514
 AliForwardMultDists.cxx:515
 AliForwardMultDists.cxx:516
 AliForwardMultDists.cxx:517
 AliForwardMultDists.cxx:518
 AliForwardMultDists.cxx:519
 AliForwardMultDists.cxx:520
 AliForwardMultDists.cxx:521
 AliForwardMultDists.cxx:522
 AliForwardMultDists.cxx:523
 AliForwardMultDists.cxx:524
 AliForwardMultDists.cxx:525
 AliForwardMultDists.cxx:526
 AliForwardMultDists.cxx:527
 AliForwardMultDists.cxx:528
 AliForwardMultDists.cxx:529
 AliForwardMultDists.cxx:530
 AliForwardMultDists.cxx:531
 AliForwardMultDists.cxx:532
 AliForwardMultDists.cxx:533
 AliForwardMultDists.cxx:534
 AliForwardMultDists.cxx:535
 AliForwardMultDists.cxx:536
 AliForwardMultDists.cxx:537
 AliForwardMultDists.cxx:538
 AliForwardMultDists.cxx:539
 AliForwardMultDists.cxx:540
 AliForwardMultDists.cxx:541
 AliForwardMultDists.cxx:542
 AliForwardMultDists.cxx:543
 AliForwardMultDists.cxx:544
 AliForwardMultDists.cxx:545
 AliForwardMultDists.cxx:546
 AliForwardMultDists.cxx:547
 AliForwardMultDists.cxx:548
 AliForwardMultDists.cxx:549
 AliForwardMultDists.cxx:550
 AliForwardMultDists.cxx:551
 AliForwardMultDists.cxx:552
 AliForwardMultDists.cxx:553
 AliForwardMultDists.cxx:554
 AliForwardMultDists.cxx:555
 AliForwardMultDists.cxx:556
 AliForwardMultDists.cxx:557
 AliForwardMultDists.cxx:558
 AliForwardMultDists.cxx:559
 AliForwardMultDists.cxx:560
 AliForwardMultDists.cxx:561
 AliForwardMultDists.cxx:562
 AliForwardMultDists.cxx:563
 AliForwardMultDists.cxx:564
 AliForwardMultDists.cxx:565
 AliForwardMultDists.cxx:566
 AliForwardMultDists.cxx:567
 AliForwardMultDists.cxx:568
 AliForwardMultDists.cxx:569
 AliForwardMultDists.cxx:570
 AliForwardMultDists.cxx:571
 AliForwardMultDists.cxx:572
 AliForwardMultDists.cxx:573
 AliForwardMultDists.cxx:574
 AliForwardMultDists.cxx:575
 AliForwardMultDists.cxx:576
 AliForwardMultDists.cxx:577
 AliForwardMultDists.cxx:578
 AliForwardMultDists.cxx:579
 AliForwardMultDists.cxx:580
 AliForwardMultDists.cxx:581
 AliForwardMultDists.cxx:582
 AliForwardMultDists.cxx:583
 AliForwardMultDists.cxx:584
 AliForwardMultDists.cxx:585
 AliForwardMultDists.cxx:586
 AliForwardMultDists.cxx:587
 AliForwardMultDists.cxx:588
 AliForwardMultDists.cxx:589
 AliForwardMultDists.cxx:590
 AliForwardMultDists.cxx:591
 AliForwardMultDists.cxx:592
 AliForwardMultDists.cxx:593
 AliForwardMultDists.cxx:594
 AliForwardMultDists.cxx:595
 AliForwardMultDists.cxx:596
 AliForwardMultDists.cxx:597
 AliForwardMultDists.cxx:598
 AliForwardMultDists.cxx:599
 AliForwardMultDists.cxx:600
 AliForwardMultDists.cxx:601
 AliForwardMultDists.cxx:602
 AliForwardMultDists.cxx:603
 AliForwardMultDists.cxx:604
 AliForwardMultDists.cxx:605
 AliForwardMultDists.cxx:606
 AliForwardMultDists.cxx:607
 AliForwardMultDists.cxx:608
 AliForwardMultDists.cxx:609
 AliForwardMultDists.cxx:610
 AliForwardMultDists.cxx:611
 AliForwardMultDists.cxx:612
 AliForwardMultDists.cxx:613
 AliForwardMultDists.cxx:614
 AliForwardMultDists.cxx:615
 AliForwardMultDists.cxx:616
 AliForwardMultDists.cxx:617
 AliForwardMultDists.cxx:618
 AliForwardMultDists.cxx:619
 AliForwardMultDists.cxx:620
 AliForwardMultDists.cxx:621
 AliForwardMultDists.cxx:622
 AliForwardMultDists.cxx:623
 AliForwardMultDists.cxx:624
 AliForwardMultDists.cxx:625
 AliForwardMultDists.cxx:626
 AliForwardMultDists.cxx:627
 AliForwardMultDists.cxx:628
 AliForwardMultDists.cxx:629
 AliForwardMultDists.cxx:630
 AliForwardMultDists.cxx:631
 AliForwardMultDists.cxx:632
 AliForwardMultDists.cxx:633
 AliForwardMultDists.cxx:634
 AliForwardMultDists.cxx:635
 AliForwardMultDists.cxx:636
 AliForwardMultDists.cxx:637
 AliForwardMultDists.cxx:638
 AliForwardMultDists.cxx:639
 AliForwardMultDists.cxx:640
 AliForwardMultDists.cxx:641
 AliForwardMultDists.cxx:642
 AliForwardMultDists.cxx:643
 AliForwardMultDists.cxx:644
 AliForwardMultDists.cxx:645
 AliForwardMultDists.cxx:646
 AliForwardMultDists.cxx:647
 AliForwardMultDists.cxx:648
 AliForwardMultDists.cxx:649
 AliForwardMultDists.cxx:650
 AliForwardMultDists.cxx:651
 AliForwardMultDists.cxx:652
 AliForwardMultDists.cxx:653
 AliForwardMultDists.cxx:654
 AliForwardMultDists.cxx:655
 AliForwardMultDists.cxx:656
 AliForwardMultDists.cxx:657
 AliForwardMultDists.cxx:658
 AliForwardMultDists.cxx:659
 AliForwardMultDists.cxx:660
 AliForwardMultDists.cxx:661
 AliForwardMultDists.cxx:662
 AliForwardMultDists.cxx:663
 AliForwardMultDists.cxx:664
 AliForwardMultDists.cxx:665
 AliForwardMultDists.cxx:666
 AliForwardMultDists.cxx:667
 AliForwardMultDists.cxx:668
 AliForwardMultDists.cxx:669
 AliForwardMultDists.cxx:670
 AliForwardMultDists.cxx:671
 AliForwardMultDists.cxx:672
 AliForwardMultDists.cxx:673
 AliForwardMultDists.cxx:674
 AliForwardMultDists.cxx:675
 AliForwardMultDists.cxx:676
 AliForwardMultDists.cxx:677
 AliForwardMultDists.cxx:678
 AliForwardMultDists.cxx:679
 AliForwardMultDists.cxx:680
 AliForwardMultDists.cxx:681
 AliForwardMultDists.cxx:682
 AliForwardMultDists.cxx:683
 AliForwardMultDists.cxx:684
 AliForwardMultDists.cxx:685
 AliForwardMultDists.cxx:686
 AliForwardMultDists.cxx:687
 AliForwardMultDists.cxx:688
 AliForwardMultDists.cxx:689
 AliForwardMultDists.cxx:690
 AliForwardMultDists.cxx:691
 AliForwardMultDists.cxx:692
 AliForwardMultDists.cxx:693
 AliForwardMultDists.cxx:694
 AliForwardMultDists.cxx:695
 AliForwardMultDists.cxx:696
 AliForwardMultDists.cxx:697
 AliForwardMultDists.cxx:698
 AliForwardMultDists.cxx:699
 AliForwardMultDists.cxx:700
 AliForwardMultDists.cxx:701
 AliForwardMultDists.cxx:702
 AliForwardMultDists.cxx:703
 AliForwardMultDists.cxx:704
 AliForwardMultDists.cxx:705
 AliForwardMultDists.cxx:706
 AliForwardMultDists.cxx:707
 AliForwardMultDists.cxx:708
 AliForwardMultDists.cxx:709
 AliForwardMultDists.cxx:710
 AliForwardMultDists.cxx:711
 AliForwardMultDists.cxx:712
 AliForwardMultDists.cxx:713
 AliForwardMultDists.cxx:714
 AliForwardMultDists.cxx:715
 AliForwardMultDists.cxx:716
 AliForwardMultDists.cxx:717
 AliForwardMultDists.cxx:718
 AliForwardMultDists.cxx:719
 AliForwardMultDists.cxx:720
 AliForwardMultDists.cxx:721
 AliForwardMultDists.cxx:722
 AliForwardMultDists.cxx:723
 AliForwardMultDists.cxx:724
 AliForwardMultDists.cxx:725
 AliForwardMultDists.cxx:726
 AliForwardMultDists.cxx:727
 AliForwardMultDists.cxx:728
 AliForwardMultDists.cxx:729
 AliForwardMultDists.cxx:730
 AliForwardMultDists.cxx:731
 AliForwardMultDists.cxx:732
 AliForwardMultDists.cxx:733
 AliForwardMultDists.cxx:734
 AliForwardMultDists.cxx:735
 AliForwardMultDists.cxx:736
 AliForwardMultDists.cxx:737
 AliForwardMultDists.cxx:738
 AliForwardMultDists.cxx:739
 AliForwardMultDists.cxx:740
 AliForwardMultDists.cxx:741
 AliForwardMultDists.cxx:742
 AliForwardMultDists.cxx:743
 AliForwardMultDists.cxx:744
 AliForwardMultDists.cxx:745
 AliForwardMultDists.cxx:746
 AliForwardMultDists.cxx:747
 AliForwardMultDists.cxx:748
 AliForwardMultDists.cxx:749
 AliForwardMultDists.cxx:750
 AliForwardMultDists.cxx:751
 AliForwardMultDists.cxx:752
 AliForwardMultDists.cxx:753
 AliForwardMultDists.cxx:754
 AliForwardMultDists.cxx:755
 AliForwardMultDists.cxx:756
 AliForwardMultDists.cxx:757
 AliForwardMultDists.cxx:758
 AliForwardMultDists.cxx:759
 AliForwardMultDists.cxx:760
 AliForwardMultDists.cxx:761
 AliForwardMultDists.cxx:762
 AliForwardMultDists.cxx:763
 AliForwardMultDists.cxx:764
 AliForwardMultDists.cxx:765
 AliForwardMultDists.cxx:766
 AliForwardMultDists.cxx:767
 AliForwardMultDists.cxx:768
 AliForwardMultDists.cxx:769
 AliForwardMultDists.cxx:770
 AliForwardMultDists.cxx:771
 AliForwardMultDists.cxx:772
 AliForwardMultDists.cxx:773
 AliForwardMultDists.cxx:774
 AliForwardMultDists.cxx:775
 AliForwardMultDists.cxx:776
 AliForwardMultDists.cxx:777
 AliForwardMultDists.cxx:778
 AliForwardMultDists.cxx:779
 AliForwardMultDists.cxx:780
 AliForwardMultDists.cxx:781
 AliForwardMultDists.cxx:782
 AliForwardMultDists.cxx:783
 AliForwardMultDists.cxx:784
 AliForwardMultDists.cxx:785
 AliForwardMultDists.cxx:786
 AliForwardMultDists.cxx:787
 AliForwardMultDists.cxx:788
 AliForwardMultDists.cxx:789
 AliForwardMultDists.cxx:790
 AliForwardMultDists.cxx:791
 AliForwardMultDists.cxx:792
 AliForwardMultDists.cxx:793
 AliForwardMultDists.cxx:794
 AliForwardMultDists.cxx:795
 AliForwardMultDists.cxx:796
 AliForwardMultDists.cxx:797
 AliForwardMultDists.cxx:798
 AliForwardMultDists.cxx:799
 AliForwardMultDists.cxx:800
 AliForwardMultDists.cxx:801
 AliForwardMultDists.cxx:802
 AliForwardMultDists.cxx:803
 AliForwardMultDists.cxx:804
 AliForwardMultDists.cxx:805
 AliForwardMultDists.cxx:806
 AliForwardMultDists.cxx:807
 AliForwardMultDists.cxx:808
 AliForwardMultDists.cxx:809
 AliForwardMultDists.cxx:810
 AliForwardMultDists.cxx:811
 AliForwardMultDists.cxx:812
 AliForwardMultDists.cxx:813
 AliForwardMultDists.cxx:814
 AliForwardMultDists.cxx:815
 AliForwardMultDists.cxx:816
 AliForwardMultDists.cxx:817
 AliForwardMultDists.cxx:818
 AliForwardMultDists.cxx:819
 AliForwardMultDists.cxx:820
 AliForwardMultDists.cxx:821
 AliForwardMultDists.cxx:822
 AliForwardMultDists.cxx:823
 AliForwardMultDists.cxx:824
 AliForwardMultDists.cxx:825
 AliForwardMultDists.cxx:826
 AliForwardMultDists.cxx:827
 AliForwardMultDists.cxx:828
 AliForwardMultDists.cxx:829
 AliForwardMultDists.cxx:830
 AliForwardMultDists.cxx:831
 AliForwardMultDists.cxx:832
 AliForwardMultDists.cxx:833
 AliForwardMultDists.cxx:834
 AliForwardMultDists.cxx:835
 AliForwardMultDists.cxx:836
 AliForwardMultDists.cxx:837
 AliForwardMultDists.cxx:838
 AliForwardMultDists.cxx:839
 AliForwardMultDists.cxx:840
 AliForwardMultDists.cxx:841
 AliForwardMultDists.cxx:842
 AliForwardMultDists.cxx:843
 AliForwardMultDists.cxx:844
 AliForwardMultDists.cxx:845
 AliForwardMultDists.cxx:846
 AliForwardMultDists.cxx:847
 AliForwardMultDists.cxx:848
 AliForwardMultDists.cxx:849
 AliForwardMultDists.cxx:850
 AliForwardMultDists.cxx:851
 AliForwardMultDists.cxx:852
 AliForwardMultDists.cxx:853
 AliForwardMultDists.cxx:854
 AliForwardMultDists.cxx:855
 AliForwardMultDists.cxx:856
 AliForwardMultDists.cxx:857
 AliForwardMultDists.cxx:858
 AliForwardMultDists.cxx:859
 AliForwardMultDists.cxx:860
 AliForwardMultDists.cxx:861
 AliForwardMultDists.cxx:862
 AliForwardMultDists.cxx:863
 AliForwardMultDists.cxx:864
 AliForwardMultDists.cxx:865
 AliForwardMultDists.cxx:866
 AliForwardMultDists.cxx:867
 AliForwardMultDists.cxx:868
 AliForwardMultDists.cxx:869
 AliForwardMultDists.cxx:870
 AliForwardMultDists.cxx:871
 AliForwardMultDists.cxx:872
 AliForwardMultDists.cxx:873
 AliForwardMultDists.cxx:874
 AliForwardMultDists.cxx:875
 AliForwardMultDists.cxx:876
 AliForwardMultDists.cxx:877
 AliForwardMultDists.cxx:878
 AliForwardMultDists.cxx:879
 AliForwardMultDists.cxx:880
 AliForwardMultDists.cxx:881
 AliForwardMultDists.cxx:882
 AliForwardMultDists.cxx:883
 AliForwardMultDists.cxx:884
 AliForwardMultDists.cxx:885
 AliForwardMultDists.cxx:886
 AliForwardMultDists.cxx:887
 AliForwardMultDists.cxx:888
 AliForwardMultDists.cxx:889
 AliForwardMultDists.cxx:890
 AliForwardMultDists.cxx:891
 AliForwardMultDists.cxx:892
 AliForwardMultDists.cxx:893
 AliForwardMultDists.cxx:894
 AliForwardMultDists.cxx:895
 AliForwardMultDists.cxx:896
 AliForwardMultDists.cxx:897
 AliForwardMultDists.cxx:898
 AliForwardMultDists.cxx:899
 AliForwardMultDists.cxx:900
 AliForwardMultDists.cxx:901
 AliForwardMultDists.cxx:902
 AliForwardMultDists.cxx:903
 AliForwardMultDists.cxx:904
 AliForwardMultDists.cxx:905
 AliForwardMultDists.cxx:906
 AliForwardMultDists.cxx:907
 AliForwardMultDists.cxx:908
 AliForwardMultDists.cxx:909
 AliForwardMultDists.cxx:910
 AliForwardMultDists.cxx:911
 AliForwardMultDists.cxx:912
 AliForwardMultDists.cxx:913
 AliForwardMultDists.cxx:914
 AliForwardMultDists.cxx:915
 AliForwardMultDists.cxx:916
 AliForwardMultDists.cxx:917
 AliForwardMultDists.cxx:918
 AliForwardMultDists.cxx:919
 AliForwardMultDists.cxx:920
 AliForwardMultDists.cxx:921
 AliForwardMultDists.cxx:922
 AliForwardMultDists.cxx:923
 AliForwardMultDists.cxx:924
 AliForwardMultDists.cxx:925
 AliForwardMultDists.cxx:926
 AliForwardMultDists.cxx:927
 AliForwardMultDists.cxx:928
 AliForwardMultDists.cxx:929
 AliForwardMultDists.cxx:930
 AliForwardMultDists.cxx:931
 AliForwardMultDists.cxx:932
 AliForwardMultDists.cxx:933
 AliForwardMultDists.cxx:934
 AliForwardMultDists.cxx:935
 AliForwardMultDists.cxx:936
 AliForwardMultDists.cxx:937
 AliForwardMultDists.cxx:938
 AliForwardMultDists.cxx:939
 AliForwardMultDists.cxx:940
 AliForwardMultDists.cxx:941
 AliForwardMultDists.cxx:942
 AliForwardMultDists.cxx:943
 AliForwardMultDists.cxx:944
 AliForwardMultDists.cxx:945
 AliForwardMultDists.cxx:946
 AliForwardMultDists.cxx:947
 AliForwardMultDists.cxx:948
 AliForwardMultDists.cxx:949
 AliForwardMultDists.cxx:950
 AliForwardMultDists.cxx:951
 AliForwardMultDists.cxx:952
 AliForwardMultDists.cxx:953
 AliForwardMultDists.cxx:954
 AliForwardMultDists.cxx:955
 AliForwardMultDists.cxx:956
 AliForwardMultDists.cxx:957
 AliForwardMultDists.cxx:958
 AliForwardMultDists.cxx:959
 AliForwardMultDists.cxx:960
 AliForwardMultDists.cxx:961
 AliForwardMultDists.cxx:962
 AliForwardMultDists.cxx:963
 AliForwardMultDists.cxx:964
 AliForwardMultDists.cxx:965
 AliForwardMultDists.cxx:966
 AliForwardMultDists.cxx:967
 AliForwardMultDists.cxx:968
 AliForwardMultDists.cxx:969
 AliForwardMultDists.cxx:970
 AliForwardMultDists.cxx:971
 AliForwardMultDists.cxx:972
 AliForwardMultDists.cxx:973
 AliForwardMultDists.cxx:974
 AliForwardMultDists.cxx:975
 AliForwardMultDists.cxx:976
 AliForwardMultDists.cxx:977
 AliForwardMultDists.cxx:978
 AliForwardMultDists.cxx:979
 AliForwardMultDists.cxx:980
 AliForwardMultDists.cxx:981
 AliForwardMultDists.cxx:982
 AliForwardMultDists.cxx:983
 AliForwardMultDists.cxx:984
 AliForwardMultDists.cxx:985
 AliForwardMultDists.cxx:986
 AliForwardMultDists.cxx:987
 AliForwardMultDists.cxx:988
 AliForwardMultDists.cxx:989
 AliForwardMultDists.cxx:990
 AliForwardMultDists.cxx:991
 AliForwardMultDists.cxx:992
 AliForwardMultDists.cxx:993
 AliForwardMultDists.cxx:994
 AliForwardMultDists.cxx:995
 AliForwardMultDists.cxx:996
 AliForwardMultDists.cxx:997
 AliForwardMultDists.cxx:998
 AliForwardMultDists.cxx:999
 AliForwardMultDists.cxx:1000
 AliForwardMultDists.cxx:1001
 AliForwardMultDists.cxx:1002
 AliForwardMultDists.cxx:1003
 AliForwardMultDists.cxx:1004
 AliForwardMultDists.cxx:1005
 AliForwardMultDists.cxx:1006
 AliForwardMultDists.cxx:1007
 AliForwardMultDists.cxx:1008
 AliForwardMultDists.cxx:1009
 AliForwardMultDists.cxx:1010
 AliForwardMultDists.cxx:1011
 AliForwardMultDists.cxx:1012
 AliForwardMultDists.cxx:1013
 AliForwardMultDists.cxx:1014
 AliForwardMultDists.cxx:1015
 AliForwardMultDists.cxx:1016
 AliForwardMultDists.cxx:1017
 AliForwardMultDists.cxx:1018
 AliForwardMultDists.cxx:1019
 AliForwardMultDists.cxx:1020
 AliForwardMultDists.cxx:1021
 AliForwardMultDists.cxx:1022
 AliForwardMultDists.cxx:1023
 AliForwardMultDists.cxx:1024
 AliForwardMultDists.cxx:1025
 AliForwardMultDists.cxx:1026
 AliForwardMultDists.cxx:1027
 AliForwardMultDists.cxx:1028
 AliForwardMultDists.cxx:1029
 AliForwardMultDists.cxx:1030
 AliForwardMultDists.cxx:1031
 AliForwardMultDists.cxx:1032
 AliForwardMultDists.cxx:1033
 AliForwardMultDists.cxx:1034
 AliForwardMultDists.cxx:1035
 AliForwardMultDists.cxx:1036
 AliForwardMultDists.cxx:1037
 AliForwardMultDists.cxx:1038
 AliForwardMultDists.cxx:1039
 AliForwardMultDists.cxx:1040
 AliForwardMultDists.cxx:1041
 AliForwardMultDists.cxx:1042
 AliForwardMultDists.cxx:1043
 AliForwardMultDists.cxx:1044
 AliForwardMultDists.cxx:1045
 AliForwardMultDists.cxx:1046
 AliForwardMultDists.cxx:1047
 AliForwardMultDists.cxx:1048
 AliForwardMultDists.cxx:1049
 AliForwardMultDists.cxx:1050
 AliForwardMultDists.cxx:1051
 AliForwardMultDists.cxx:1052
 AliForwardMultDists.cxx:1053
 AliForwardMultDists.cxx:1054
 AliForwardMultDists.cxx:1055
 AliForwardMultDists.cxx:1056
 AliForwardMultDists.cxx:1057
 AliForwardMultDists.cxx:1058
 AliForwardMultDists.cxx:1059
 AliForwardMultDists.cxx:1060
 AliForwardMultDists.cxx:1061
 AliForwardMultDists.cxx:1062
 AliForwardMultDists.cxx:1063
 AliForwardMultDists.cxx:1064
 AliForwardMultDists.cxx:1065
 AliForwardMultDists.cxx:1066
 AliForwardMultDists.cxx:1067
 AliForwardMultDists.cxx:1068
 AliForwardMultDists.cxx:1069
 AliForwardMultDists.cxx:1070
 AliForwardMultDists.cxx:1071
 AliForwardMultDists.cxx:1072
 AliForwardMultDists.cxx:1073
 AliForwardMultDists.cxx:1074
 AliForwardMultDists.cxx:1075
 AliForwardMultDists.cxx:1076
 AliForwardMultDists.cxx:1077
 AliForwardMultDists.cxx:1078
 AliForwardMultDists.cxx:1079
 AliForwardMultDists.cxx:1080
 AliForwardMultDists.cxx:1081
 AliForwardMultDists.cxx:1082
 AliForwardMultDists.cxx:1083
 AliForwardMultDists.cxx:1084
 AliForwardMultDists.cxx:1085
 AliForwardMultDists.cxx:1086
 AliForwardMultDists.cxx:1087
 AliForwardMultDists.cxx:1088
 AliForwardMultDists.cxx:1089
 AliForwardMultDists.cxx:1090
 AliForwardMultDists.cxx:1091
 AliForwardMultDists.cxx:1092
 AliForwardMultDists.cxx:1093
 AliForwardMultDists.cxx:1094
 AliForwardMultDists.cxx:1095
 AliForwardMultDists.cxx:1096
 AliForwardMultDists.cxx:1097
 AliForwardMultDists.cxx:1098
 AliForwardMultDists.cxx:1099
 AliForwardMultDists.cxx:1100
 AliForwardMultDists.cxx:1101
 AliForwardMultDists.cxx:1102