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: AliESD.cxx 54579 2012-02-14 12:22:34Z shahoian $ */

//-----------------------------------------------------------------
//           Implementation of the ESD class
//   This is the class to deal with during the phisical analysis of data
//   This class is generated directly by the reconstruction methods
//      Origin: Iouri Belikov, CERN, Jouri.Belikov@cern.ch
//-----------------------------------------------------------------

#include "AliESD.h"
#include "AliESDfriend.h"

ClassImp(AliESD)

//______________________________________________________________________________
AliESD::AliESD():
  fEventNumberInFile(0),
  fBunchCrossNumber(0),
  fOrbitNumber(0),
  fPeriodNumber(0),
  fRunNumber(0),
  fTimeStamp(0),
  fEventType(0),
  fTriggerMask(0),
  fTriggerMaskNext50(0),
  fTriggerCluster(0),
  fRecoVersion(0),
  fMagneticField(0),
  fZDCN1Energy(0),
  fZDCP1Energy(0),
  fZDCN2Energy(0),
  fZDCP2Energy(0),
  fZDCEMEnergy(0),
  fZDCParticipants(0),
  fT0zVertex(0),
  fSPDVertex(),
  fPrimaryVertex(),
  fSPDMult(),
  fT0clock(0),
  fT0timeStart(0),
  fT0trig(0),
  fTracks("AliESDtrack",15000),
  fHLTConfMapTracks("AliESDHLTtrack",25000),
  fHLTHoughTracks("AliESDHLTtrack",15000),
  fMuonTracks("AliESDMuonTrack",30),
  fPmdTracks("AliESDPmdTrack",3000),
  fTrdTracks("AliESDTrdTrack",300),
  fV0s("AliESDv0",200),  
  fCascades("AliESDcascade",20),
  fKinks("AliESDkink",4000),
  fCaloClusters("AliESDCaloCluster",10000),
  fEMCALClusters(0), 
  fFirstEMCALCluster(-1),
  fEMCALTriggerPosition(0x0),
  fEMCALTriggerAmplitudes(0x0),
  fPHOSClusters(0), 
  fFirstPHOSCluster(-1),
  fPHOSTriggerPosition(0x0),
  fPHOSTriggerAmplitudes(0x0),
  fESDFMD(0x0),
  fESDVZERO(0x0),
  fESDACORDE(0x0),
  fESDAD(0x0),
  fErrorLogs("AliRawDataErrorLog",5)
{
  // 
  // Standar constructor
  //

   for (Int_t i=0; i<3; i++) fT0TOF[i] = 0;
 for (Int_t i=0; i<24; i++) {
    fT0time[i] = 0;
    fT0amplitude[i] = 0;
  }
  for (Int_t i=0; i<2; i++) fDiamondXY[i]=0.;
  for (Int_t i=0; i<3; i++) fDiamondCovXY[i]=0.;
}

//______________________________________________________________________________
AliESD::AliESD(const AliESD& esd):
  TObject(esd),
  fEventNumberInFile(esd.fEventNumberInFile),
  fBunchCrossNumber(esd.fBunchCrossNumber),
  fOrbitNumber(esd.fOrbitNumber),
  fPeriodNumber(esd.fPeriodNumber),
  fRunNumber(esd.fRunNumber),
  fTimeStamp(esd.fTimeStamp),
  fEventType(esd.fEventType),
  fTriggerMask(esd.fTriggerMask),
  fTriggerMaskNext50(esd.fTriggerMaskNext50),
  fTriggerCluster(esd.fTriggerCluster),
  fRecoVersion(esd.fRecoVersion),
  fMagneticField(esd.fMagneticField),
  fZDCN1Energy(esd.fZDCN1Energy),
  fZDCP1Energy(esd.fZDCP1Energy),
  fZDCN2Energy(esd.fZDCN2Energy),
  fZDCP2Energy(esd.fZDCP2Energy),
  fZDCEMEnergy(esd.fZDCEMEnergy),
  fZDCParticipants(esd.fZDCParticipants),
  fT0zVertex(esd.fT0zVertex),
  fSPDVertex(esd.fSPDVertex),
  fPrimaryVertex(esd.fPrimaryVertex),
  fSPDMult(esd.fSPDMult),
  fT0clock(esd.fT0clock),
  fT0timeStart(esd.fT0timeStart),
  fT0trig(esd.fT0trig),
  fTracks(*((TClonesArray*)esd.fTracks.Clone())),
  fHLTConfMapTracks(*((TClonesArray*)esd.fHLTConfMapTracks.Clone())),
  fHLTHoughTracks(*((TClonesArray*)esd.fHLTHoughTracks.Clone())),
  fMuonTracks(*((TClonesArray*)esd.fMuonTracks.Clone())),
  fPmdTracks(*((TClonesArray*)esd.fPmdTracks.Clone())),
  fTrdTracks(*((TClonesArray*)esd.fTrdTracks.Clone())),
  fV0s(*((TClonesArray*)esd.fV0s.Clone())),  
  fCascades(*((TClonesArray*)esd.fCascades.Clone())),
  fKinks(*((TClonesArray*)esd.fKinks.Clone())),
  fCaloClusters(*((TClonesArray*)esd.fCaloClusters.Clone())),
  fEMCALClusters(esd.fEMCALClusters), 
  fFirstEMCALCluster(esd.fFirstEMCALCluster),
  fEMCALTriggerPosition(esd. fEMCALTriggerPosition),
  fEMCALTriggerAmplitudes(esd.fEMCALTriggerAmplitudes),
  fPHOSClusters(esd.fPHOSClusters), 
  fFirstPHOSCluster(esd.fFirstPHOSCluster),
  fPHOSTriggerPosition(esd.fPHOSTriggerPosition),
  fPHOSTriggerAmplitudes(esd.fPHOSTriggerAmplitudes),
  fESDFMD(esd.fESDFMD),
  fESDVZERO(esd.fESDVZERO),
  fESDACORDE(esd.fESDACORDE),
  fESDAD(esd.fESDAD),
  fErrorLogs(*((TClonesArray*)esd.fErrorLogs.Clone()))
{
  // 
  // copy constructor
  //
  for (Int_t i=0; i<3; i++)fT0TOF[i] = esd.fT0TOF[i];
  for (Int_t i=0; i<24; i++) {
    fT0time[i] = esd.fT0time[i];
    fT0amplitude[i] = esd.fT0amplitude[i];
  }
  for (Int_t i=0; i<2; i++) fDiamondXY[i]=esd.fDiamondXY[i];
  for (Int_t i=0; i<3; i++) fDiamondCovXY[i]=esd.fDiamondCovXY[i];
}

//______________________________________________________________________________
AliESD::~AliESD()
{
  //
  // Standard destructor
  //
  fTracks.Delete();
  fHLTConfMapTracks.Delete();
  fHLTHoughTracks.Delete();
  fMuonTracks.Delete();
  fPmdTracks.Delete();
  fTrdTracks.Delete();
  fV0s.Delete();
  fCascades.Delete();
  fKinks.Delete();
  fCaloClusters.Delete();
  delete fESDFMD;
  delete fESDVZERO;
  delete fEMCALTriggerPosition;
  delete fEMCALTriggerAmplitudes;
  delete fPHOSTriggerPosition;
  delete fPHOSTriggerAmplitudes;
  delete fESDACORDE;
  delete fESDAD;
  fErrorLogs.Delete();

}

//______________________________________________________________________________
void AliESD::Reset()
{
  // 
  // Reset the contents and delete the entries in TClonesArrays
  //

  fEventNumberInFile=0;
  fBunchCrossNumber=0;
  fOrbitNumber=0;
  fPeriodNumber=0;
  fRunNumber=0;
  fTimeStamp = 0;
  fEventType = 0;
  fTriggerMask=0;
  fTriggerMaskNext50=0;
  fTriggerCluster=0;
  fRecoVersion=0;
  fMagneticField=0;
  fZDCN1Energy=0;
  fZDCP1Energy=0;
  fZDCN2Energy=0;
  fZDCP2Energy=0;
  fZDCEMEnergy=0;
  fZDCParticipants=0;
  fT0zVertex=0;
  
  for (Int_t i=0; i<2; i++) fDiamondXY[i]=0.;
  for (Int_t i=0; i<3; i++) fDiamondCovXY[i]=0.;

  for (Int_t i=0; i<24; i++) {
    fT0time[i] = 0;
    fT0amplitude[i] = 0;
  }
  fT0timeStart = 0;
  fT0clock = 0;
  for (Int_t i=0; i<3; i++) fT0TOF[i] = 0;
//
  fSPDMult.~AliMultiplicity();
  new (&fSPDMult) AliMultiplicity();
  fSPDVertex.~AliESDVertex();
  new (&fSPDVertex) AliESDVertex();
  fPrimaryVertex.~AliESDVertex();
  new (&fPrimaryVertex) AliESDVertex();
//
  fTracks.Delete();
  fHLTConfMapTracks.Delete();
  fHLTHoughTracks.Delete();
  fMuonTracks.Delete();
  fPmdTracks.Delete();
  fTrdTracks.Delete();
  fV0s.Delete();
  fCascades.Delete();
  fKinks.Delete();
  fCaloClusters.Delete();
//
  fEMCALClusters=0; 
  fFirstEMCALCluster=-1; 
  fPHOSClusters=0; 
  fFirstPHOSCluster=-1; 
//
  if (fEMCALTriggerPosition)   fEMCALTriggerPosition  ->Reset();
  if (fEMCALTriggerAmplitudes) fEMCALTriggerAmplitudes->Reset();
  if (fPHOSTriggerPosition)    fPHOSTriggerPosition   ->Reset();
  if (fPHOSTriggerAmplitudes)  fPHOSTriggerAmplitudes ->Reset();
//
  if (fESDFMD) fESDFMD->Clear();
//
  if (fESDVZERO){
      fESDVZERO->~AliESDVZERO();
      new (fESDVZERO) AliESDVZERO();
  } 
//
  if (fESDACORDE){
      fESDACORDE->~AliESDACORDE();
      new (fESDACORDE) AliESDACORDE();	
  }	

 if (fESDAD){
      fESDAD->~AliESDAD();
      new (fESDAD) AliESDAD();	
  }	

//
//
  fErrorLogs.Delete();
}


Bool_t  AliESD::RemoveKink(Int_t rm) {
  // ---------------------------------------------------------
  // Remove a kink candidate and references to it from ESD,
  // if this candidate does not come from a reconstructed decay
  // Not yet implemented...
  // ---------------------------------------------------------
  Int_t last=GetNumberOfKinks()-1;
  if ((rm<0)||(rm>last)) return kFALSE;

  return kTRUE;
}

Bool_t  AliESD::RemoveV0(Int_t rm) {
  // ---------------------------------------------------------
  // Remove a V0 candidate and references to it from ESD,
  // if this candidate does not come from a reconstructed decay
  // ---------------------------------------------------------
  Int_t last=GetNumberOfV0s()-1;
  if ((rm<0)||(rm>last)) return kFALSE;

  AliESDv0 *v0=GetV0(rm);
  Int_t idxP=v0->GetPindex(), idxN=v0->GetNindex();

  v0=GetV0(last);
  Int_t lastIdxP=v0->GetPindex(), lastIdxN=v0->GetNindex();

  Int_t used=0;

  // Check if this V0 comes from a reconstructed decay
  Int_t ncs=GetNumberOfCascades();
  for (Int_t n=0; n<ncs; n++) {
    AliESDcascade *cs=GetCascade(n);

    Int_t csIdxP=cs->GetPindex();
    Int_t csIdxN=cs->GetNindex();

    if (idxP==csIdxP)
       if (idxN==csIdxN) return kFALSE;

    if (csIdxP==lastIdxP)
       if (csIdxN==lastIdxN) used++;
  }

  //Replace the removed V0 with the last V0 
  TClonesArray &a=fV0s;
  delete a.RemoveAt(rm);

  if (rm==last) return kTRUE;

  //v0 is pointing to the last V0 candidate... 
  new (a[rm]) AliESDv0(*v0);
  delete a.RemoveAt(last);

  if (!used) return kTRUE;
  

  // Remap the indices of the daughters of reconstructed decays
  for (Int_t n=0; n<ncs; n++) {
    AliESDcascade *cs=GetCascade(n);


    Int_t csIdxP=cs->GetPindex();
    Int_t csIdxN=cs->GetNindex();

    if (csIdxP==lastIdxP)
      if (csIdxN==lastIdxN) {
         cs->AliESDv0::SetIndex(1,idxP);
         cs->AliESDv0::SetIndex(0,idxN);
         used--;
         if (!used) return kTRUE;
      }
  }

  return kTRUE;
}

Bool_t  AliESD::RemoveTrack(Int_t rm) {
  // ---------------------------------------------------------
  // Remove a track and references to it from ESD,
  // if this track does not come from a reconstructed decay
  // ---------------------------------------------------------
  Int_t last=GetNumberOfTracks()-1;
  if ((rm<0)||(rm>last)) return kFALSE;

  Int_t used=0;

  // Check if this track comes from the reconstructed primary vertex
  if (fPrimaryVertex.GetStatus()) {
     UShort_t *primIdx=fPrimaryVertex.GetIndices();
     Int_t n=fPrimaryVertex.GetNIndices();
     while (n--) {
       Int_t idx=Int_t(primIdx[n]);
       if (rm==idx) return kFALSE;
       if (idx==last) used++; 
     }
  }
  
  // Check if this track comes from a reconstructed decay
  Int_t nv0=GetNumberOfV0s();
  for (Int_t n=0; n<nv0; n++) {
    AliESDv0 *v0=GetV0(n);

    Int_t idx=v0->GetNindex();
    if (rm==idx) return kFALSE;
    if (idx==last) used++;

    idx=v0->GetPindex();
    if (rm==idx) return kFALSE;
    if (idx==last) used++;
  }

  Int_t ncs=GetNumberOfCascades();
  for (Int_t n=0; n<ncs; n++) {
    AliESDcascade *cs=GetCascade(n);

    Int_t idx=cs->GetIndex();
    if (rm==idx) return kFALSE;
    if (idx==last) used++;
  }

  Int_t nkn=GetNumberOfKinks();
  for (Int_t n=0; n<nkn; n++) {
    AliESDkink *kn=GetKink(n);

    Int_t idx=kn->GetIndex(0);
    if (rm==idx) return kFALSE;
    if (idx==last) used++;

    idx=kn->GetIndex(1);
    if (rm==idx) return kFALSE;
    if (idx==last) used++;
  }


  //Replace the removed track with the last track 
  TClonesArray &a=fTracks;
  delete a.RemoveAt(rm);

  if (rm==last) return kTRUE;

  AliESDtrack *t=GetTrack(last);
  if (!t) {AliFatal(Form("NULL pointer for ESD track %d",last)); return kFALSE;}
  t->SetID(rm);
  new (a[rm]) AliESDtrack(*t);
  delete a.RemoveAt(last);


  if (!used) return kTRUE;
  

  // Remap the indices of the tracks used for the primary vertex reconstruction
  if (fPrimaryVertex.GetStatus()) {
     UShort_t *primIdx=fPrimaryVertex.GetIndices();
     Int_t n=fPrimaryVertex.GetNIndices();
     while (n--) {
       Int_t idx=Int_t(primIdx[n]);
       if (idx==last) {
          primIdx[n]=Short_t(rm); 
          used--;
          if (!used) return kTRUE;
       }
     }
  }
  
  // Remap the indices of the daughters of reconstructed decays
  for (Int_t n=0; n<nv0; n++) {
    AliESDv0 *v0=GetV0(n);
    if (v0->GetIndex(0)==last) {
       v0->SetIndex(0,rm);
       used--;
       if (!used) return kTRUE;
    }
    if (v0->GetIndex(1)==last) {
       v0->SetIndex(1,rm);
       used--;
       if (!used) return kTRUE;
    }
  }

  for (Int_t n=0; n<ncs; n++) {
    AliESDcascade *cs=GetCascade(n);
    if (cs->GetIndex()==last) {
       cs->SetIndex(rm);
       used--;
       if (!used) return kTRUE;
    }
  }

  for (Int_t n=0; n<nkn; n++) {
    AliESDkink *kn=GetKink(n);
    if (kn->GetIndex(0)==last) {
       kn->SetIndex(rm,0);
       used--;
       if (!used) return kTRUE;
    }
    if (kn->GetIndex(1)==last) {
       kn->SetIndex(rm,1);
       used--;
       if (!used) return kTRUE;
    }
  }

  return kTRUE;
}


Bool_t AliESD::Clean(Float_t *cleanPars) {
  //
  // Remove the data which are not needed for the physics analysis.
  //
  // 1) Cleaning the V0 candidates
  //    ---------------------------
  //    If the cosine of the V0 pointing angle "csp" and 
  //    the DCA between the daughter tracks "dca" does not satisfy 
  //    the conditions 
  //
  //     csp > cleanPars[1] + dca/cleanPars[0]*(1.- cleanPars[1])
  //
  //    an attempt to remove this V0 candidate from ESD is made.
  //
  //    The V0 candidate gets removed if it does not belong to any 
  //    recosntructed cascade decay
  //
  //    12.11.2007, optimal values: cleanPars[0]=0.5, cleanPars[1]=0.999
  //
  // 2) Cleaning the tracks
  //    ----------------------
  //    If track's transverse parameter is larger than cleanPars[2]
  //                       OR
  //    track's longitudinal parameter is larger than cleanPars[3]
  //    an attempt to remove this track from ESD is made.
  //
  //    The track gets removed if it does not come 
  //    from a reconstructed decay
  //
  Bool_t rc=kFALSE;

  Float_t dcaMax=cleanPars[0];
  Float_t cspMin=cleanPars[1];

  Int_t nV0s=GetNumberOfV0s();
  for (Int_t i=nV0s-1; i>=0; i--) {
    AliESDv0 *v0=GetV0(i);

    Float_t dca=v0->GetDcaV0Daughters();
    Float_t csp=v0->GetV0CosineOfPointingAngle();
    Float_t cspcut=cspMin + dca/dcaMax*(1.-cspMin);
    if (csp > cspcut) continue;

    if (RemoveV0(i)) rc=kTRUE;
  }


  Float_t dmax=cleanPars[2], zmax=cleanPars[3];

  const AliESDVertex *vertex=GetVertex();
  Bool_t vtxOK=vertex->GetStatus();
  
  Int_t nTracks=GetNumberOfTracks();
  for (Int_t i=nTracks-1; i>=0; i--) {
    AliESDtrack *track=GetTrack(i);
    if (!track) {AliFatal(Form("NULL pointer for ESD track %d",i)); return kFALSE;}
    Float_t xy,z; track->GetImpactParameters(xy,z);
    if ((TMath::Abs(xy) > dmax) || (vtxOK && (TMath::Abs(z) > zmax))) {
      if (RemoveTrack(i)) rc=kTRUE;
    }
  }

  return rc;
}

Int_t AliESD::AddV0(const AliESDv0 *v) {
  //
  // Add V0
  //
    Int_t idx=fV0s.GetEntriesFast();
    new(fV0s[idx]) AliESDv0(*v);
    return idx;
}  

//______________________________________________________________________________
void AliESD::Print(Option_t *) const 
{
  //
  // Print header information of the event
  //
  printf("ESD run information\n");
  printf("Event # in file %d Bunch crossing # %d Orbit # %d Period # %d Run # %d Trigger %lld %lld Magnetic field %f \n",
	 GetEventNumberInFile(),
	 GetBunchCrossNumber(),
	 GetOrbitNumber(),
	 GetPeriodNumber(),
	 GetRunNumber(),
	 GetTriggerMask(),
	 GetTriggerMaskNext50(),
	 GetMagneticField() );
    printf("Vertex: (%.4f +- %.4f, %.4f +- %.4f, %.4f +- %.4f) cm\n",
	   fPrimaryVertex.GetX(), fPrimaryVertex.GetXRes(),
	   fPrimaryVertex.GetY(), fPrimaryVertex.GetYRes(),
	   fPrimaryVertex.GetZ(), fPrimaryVertex.GetZRes());
    printf("Mean vertex in RUN: X=%.4f Y=%.4f cm\n",
	   GetDiamondX(),GetDiamondY());
    printf("SPD Multiplicity. Number of tracklets %d \n",
           fSPDMult.GetNumberOfTracklets());
  printf("Event from reconstruction version %d \n",fRecoVersion);
  printf("Number of tracks: \n");
  printf("                 charged   %d\n", GetNumberOfTracks());
  printf("                 hlt CF    %d\n", GetNumberOfHLTConfMapTracks());
  printf("                 hlt HT    %d\n", GetNumberOfHLTHoughTracks());
  printf("                 muon      %d\n", GetNumberOfMuonTracks());
  printf("                 pmd       %d\n", GetNumberOfPmdTracks());
  printf("                 trd       %d\n", GetNumberOfTrdTracks());
  printf("                 v0        %d\n", GetNumberOfV0s());
  printf("                 cascades  %d\n", GetNumberOfCascades());
  printf("                 kinks     %d\n", GetNumberOfKinks());
  printf("                 CaloClusters %d\n", GetNumberOfCaloClusters());
  printf("                 phos      %d\n", GetNumberOfPHOSClusters());
  printf("                 emcal     %d\n", GetNumberOfEMCALClusters());
  printf("                 FMD       %s\n", (fESDFMD ? "yes" : "no"));
  printf("                 VZERO     %s\n", (fESDVZERO ? "yes" : "no"));
}

void AliESD::SetESDfriend(const AliESDfriend *ev) {
  //
  // Attaches the complementary info to the ESD
  //
  if (!ev) return;

  Int_t ntrk=ev->GetNumberOfTracks();

  for (Int_t i=0; i<ntrk; i++) {
    const AliESDfriendTrack *f=ev->GetTrack(i);
    if (!f) {AliFatal(Form("NULL pointer for ESD track %d",i));}
    GetTrack(i)->SetFriendTrack(f);
  }
}

void AliESD::GetESDfriend(AliESDfriend *ev) const {
  //
  // Extracts the complementary info from the ESD
  //
  if (!ev) return;

  Int_t ntrk=GetNumberOfTracks();

  for (Int_t i=0; i<ntrk; i++) {
    AliESDtrack *t=GetTrack(i);
    if (!t) {AliFatal(Form("NULL pointer for ESD track %d",i));}
    const AliESDfriendTrack *f=t->GetFriendTrack();
    ev->AddTrack(f);

    t->ReleaseESDfriendTrack();// Not to have two copies of "friendTrack"

  }
}

void AliESD::SetDiamond(const AliESDVertex *vertex)
{
  //
  // Set the interaction diamond
  //  
    fDiamondXY[0]=vertex->GetX();
    fDiamondXY[1]=vertex->GetY();
    Double_t cov[6];
    vertex->GetCovMatrix(cov);
    fDiamondCovXY[0]=cov[0];
    fDiamondCovXY[1]=cov[1];
    fDiamondCovXY[2]=cov[2];
  }
 AliESD.cxx:1
 AliESD.cxx:2
 AliESD.cxx:3
 AliESD.cxx:4
 AliESD.cxx:5
 AliESD.cxx:6
 AliESD.cxx:7
 AliESD.cxx:8
 AliESD.cxx:9
 AliESD.cxx:10
 AliESD.cxx:11
 AliESD.cxx:12
 AliESD.cxx:13
 AliESD.cxx:14
 AliESD.cxx:15
 AliESD.cxx:16
 AliESD.cxx:17
 AliESD.cxx:18
 AliESD.cxx:19
 AliESD.cxx:20
 AliESD.cxx:21
 AliESD.cxx:22
 AliESD.cxx:23
 AliESD.cxx:24
 AliESD.cxx:25
 AliESD.cxx:26
 AliESD.cxx:27
 AliESD.cxx:28
 AliESD.cxx:29
 AliESD.cxx:30
 AliESD.cxx:31
 AliESD.cxx:32
 AliESD.cxx:33
 AliESD.cxx:34
 AliESD.cxx:35
 AliESD.cxx:36
 AliESD.cxx:37
 AliESD.cxx:38
 AliESD.cxx:39
 AliESD.cxx:40
 AliESD.cxx:41
 AliESD.cxx:42
 AliESD.cxx:43
 AliESD.cxx:44
 AliESD.cxx:45
 AliESD.cxx:46
 AliESD.cxx:47
 AliESD.cxx:48
 AliESD.cxx:49
 AliESD.cxx:50
 AliESD.cxx:51
 AliESD.cxx:52
 AliESD.cxx:53
 AliESD.cxx:54
 AliESD.cxx:55
 AliESD.cxx:56
 AliESD.cxx:57
 AliESD.cxx:58
 AliESD.cxx:59
 AliESD.cxx:60
 AliESD.cxx:61
 AliESD.cxx:62
 AliESD.cxx:63
 AliESD.cxx:64
 AliESD.cxx:65
 AliESD.cxx:66
 AliESD.cxx:67
 AliESD.cxx:68
 AliESD.cxx:69
 AliESD.cxx:70
 AliESD.cxx:71
 AliESD.cxx:72
 AliESD.cxx:73
 AliESD.cxx:74
 AliESD.cxx:75
 AliESD.cxx:76
 AliESD.cxx:77
 AliESD.cxx:78
 AliESD.cxx:79
 AliESD.cxx:80
 AliESD.cxx:81
 AliESD.cxx:82
 AliESD.cxx:83
 AliESD.cxx:84
 AliESD.cxx:85
 AliESD.cxx:86
 AliESD.cxx:87
 AliESD.cxx:88
 AliESD.cxx:89
 AliESD.cxx:90
 AliESD.cxx:91
 AliESD.cxx:92
 AliESD.cxx:93
 AliESD.cxx:94
 AliESD.cxx:95
 AliESD.cxx:96
 AliESD.cxx:97
 AliESD.cxx:98
 AliESD.cxx:99
 AliESD.cxx:100
 AliESD.cxx:101
 AliESD.cxx:102
 AliESD.cxx:103
 AliESD.cxx:104
 AliESD.cxx:105
 AliESD.cxx:106
 AliESD.cxx:107
 AliESD.cxx:108
 AliESD.cxx:109
 AliESD.cxx:110
 AliESD.cxx:111
 AliESD.cxx:112
 AliESD.cxx:113
 AliESD.cxx:114
 AliESD.cxx:115
 AliESD.cxx:116
 AliESD.cxx:117
 AliESD.cxx:118
 AliESD.cxx:119
 AliESD.cxx:120
 AliESD.cxx:121
 AliESD.cxx:122
 AliESD.cxx:123
 AliESD.cxx:124
 AliESD.cxx:125
 AliESD.cxx:126
 AliESD.cxx:127
 AliESD.cxx:128
 AliESD.cxx:129
 AliESD.cxx:130
 AliESD.cxx:131
 AliESD.cxx:132
 AliESD.cxx:133
 AliESD.cxx:134
 AliESD.cxx:135
 AliESD.cxx:136
 AliESD.cxx:137
 AliESD.cxx:138
 AliESD.cxx:139
 AliESD.cxx:140
 AliESD.cxx:141
 AliESD.cxx:142
 AliESD.cxx:143
 AliESD.cxx:144
 AliESD.cxx:145
 AliESD.cxx:146
 AliESD.cxx:147
 AliESD.cxx:148
 AliESD.cxx:149
 AliESD.cxx:150
 AliESD.cxx:151
 AliESD.cxx:152
 AliESD.cxx:153
 AliESD.cxx:154
 AliESD.cxx:155
 AliESD.cxx:156
 AliESD.cxx:157
 AliESD.cxx:158
 AliESD.cxx:159
 AliESD.cxx:160
 AliESD.cxx:161
 AliESD.cxx:162
 AliESD.cxx:163
 AliESD.cxx:164
 AliESD.cxx:165
 AliESD.cxx:166
 AliESD.cxx:167
 AliESD.cxx:168
 AliESD.cxx:169
 AliESD.cxx:170
 AliESD.cxx:171
 AliESD.cxx:172
 AliESD.cxx:173
 AliESD.cxx:174
 AliESD.cxx:175
 AliESD.cxx:176
 AliESD.cxx:177
 AliESD.cxx:178
 AliESD.cxx:179
 AliESD.cxx:180
 AliESD.cxx:181
 AliESD.cxx:182
 AliESD.cxx:183
 AliESD.cxx:184
 AliESD.cxx:185
 AliESD.cxx:186
 AliESD.cxx:187
 AliESD.cxx:188
 AliESD.cxx:189
 AliESD.cxx:190
 AliESD.cxx:191
 AliESD.cxx:192
 AliESD.cxx:193
 AliESD.cxx:194
 AliESD.cxx:195
 AliESD.cxx:196
 AliESD.cxx:197
 AliESD.cxx:198
 AliESD.cxx:199
 AliESD.cxx:200
 AliESD.cxx:201
 AliESD.cxx:202
 AliESD.cxx:203
 AliESD.cxx:204
 AliESD.cxx:205
 AliESD.cxx:206
 AliESD.cxx:207
 AliESD.cxx:208
 AliESD.cxx:209
 AliESD.cxx:210
 AliESD.cxx:211
 AliESD.cxx:212
 AliESD.cxx:213
 AliESD.cxx:214
 AliESD.cxx:215
 AliESD.cxx:216
 AliESD.cxx:217
 AliESD.cxx:218
 AliESD.cxx:219
 AliESD.cxx:220
 AliESD.cxx:221
 AliESD.cxx:222
 AliESD.cxx:223
 AliESD.cxx:224
 AliESD.cxx:225
 AliESD.cxx:226
 AliESD.cxx:227
 AliESD.cxx:228
 AliESD.cxx:229
 AliESD.cxx:230
 AliESD.cxx:231
 AliESD.cxx:232
 AliESD.cxx:233
 AliESD.cxx:234
 AliESD.cxx:235
 AliESD.cxx:236
 AliESD.cxx:237
 AliESD.cxx:238
 AliESD.cxx:239
 AliESD.cxx:240
 AliESD.cxx:241
 AliESD.cxx:242
 AliESD.cxx:243
 AliESD.cxx:244
 AliESD.cxx:245
 AliESD.cxx:246
 AliESD.cxx:247
 AliESD.cxx:248
 AliESD.cxx:249
 AliESD.cxx:250
 AliESD.cxx:251
 AliESD.cxx:252
 AliESD.cxx:253
 AliESD.cxx:254
 AliESD.cxx:255
 AliESD.cxx:256
 AliESD.cxx:257
 AliESD.cxx:258
 AliESD.cxx:259
 AliESD.cxx:260
 AliESD.cxx:261
 AliESD.cxx:262
 AliESD.cxx:263
 AliESD.cxx:264
 AliESD.cxx:265
 AliESD.cxx:266
 AliESD.cxx:267
 AliESD.cxx:268
 AliESD.cxx:269
 AliESD.cxx:270
 AliESD.cxx:271
 AliESD.cxx:272
 AliESD.cxx:273
 AliESD.cxx:274
 AliESD.cxx:275
 AliESD.cxx:276
 AliESD.cxx:277
 AliESD.cxx:278
 AliESD.cxx:279
 AliESD.cxx:280
 AliESD.cxx:281
 AliESD.cxx:282
 AliESD.cxx:283
 AliESD.cxx:284
 AliESD.cxx:285
 AliESD.cxx:286
 AliESD.cxx:287
 AliESD.cxx:288
 AliESD.cxx:289
 AliESD.cxx:290
 AliESD.cxx:291
 AliESD.cxx:292
 AliESD.cxx:293
 AliESD.cxx:294
 AliESD.cxx:295
 AliESD.cxx:296
 AliESD.cxx:297
 AliESD.cxx:298
 AliESD.cxx:299
 AliESD.cxx:300
 AliESD.cxx:301
 AliESD.cxx:302
 AliESD.cxx:303
 AliESD.cxx:304
 AliESD.cxx:305
 AliESD.cxx:306
 AliESD.cxx:307
 AliESD.cxx:308
 AliESD.cxx:309
 AliESD.cxx:310
 AliESD.cxx:311
 AliESD.cxx:312
 AliESD.cxx:313
 AliESD.cxx:314
 AliESD.cxx:315
 AliESD.cxx:316
 AliESD.cxx:317
 AliESD.cxx:318
 AliESD.cxx:319
 AliESD.cxx:320
 AliESD.cxx:321
 AliESD.cxx:322
 AliESD.cxx:323
 AliESD.cxx:324
 AliESD.cxx:325
 AliESD.cxx:326
 AliESD.cxx:327
 AliESD.cxx:328
 AliESD.cxx:329
 AliESD.cxx:330
 AliESD.cxx:331
 AliESD.cxx:332
 AliESD.cxx:333
 AliESD.cxx:334
 AliESD.cxx:335
 AliESD.cxx:336
 AliESD.cxx:337
 AliESD.cxx:338
 AliESD.cxx:339
 AliESD.cxx:340
 AliESD.cxx:341
 AliESD.cxx:342
 AliESD.cxx:343
 AliESD.cxx:344
 AliESD.cxx:345
 AliESD.cxx:346
 AliESD.cxx:347
 AliESD.cxx:348
 AliESD.cxx:349
 AliESD.cxx:350
 AliESD.cxx:351
 AliESD.cxx:352
 AliESD.cxx:353
 AliESD.cxx:354
 AliESD.cxx:355
 AliESD.cxx:356
 AliESD.cxx:357
 AliESD.cxx:358
 AliESD.cxx:359
 AliESD.cxx:360
 AliESD.cxx:361
 AliESD.cxx:362
 AliESD.cxx:363
 AliESD.cxx:364
 AliESD.cxx:365
 AliESD.cxx:366
 AliESD.cxx:367
 AliESD.cxx:368
 AliESD.cxx:369
 AliESD.cxx:370
 AliESD.cxx:371
 AliESD.cxx:372
 AliESD.cxx:373
 AliESD.cxx:374
 AliESD.cxx:375
 AliESD.cxx:376
 AliESD.cxx:377
 AliESD.cxx:378
 AliESD.cxx:379
 AliESD.cxx:380
 AliESD.cxx:381
 AliESD.cxx:382
 AliESD.cxx:383
 AliESD.cxx:384
 AliESD.cxx:385
 AliESD.cxx:386
 AliESD.cxx:387
 AliESD.cxx:388
 AliESD.cxx:389
 AliESD.cxx:390
 AliESD.cxx:391
 AliESD.cxx:392
 AliESD.cxx:393
 AliESD.cxx:394
 AliESD.cxx:395
 AliESD.cxx:396
 AliESD.cxx:397
 AliESD.cxx:398
 AliESD.cxx:399
 AliESD.cxx:400
 AliESD.cxx:401
 AliESD.cxx:402
 AliESD.cxx:403
 AliESD.cxx:404
 AliESD.cxx:405
 AliESD.cxx:406
 AliESD.cxx:407
 AliESD.cxx:408
 AliESD.cxx:409
 AliESD.cxx:410
 AliESD.cxx:411
 AliESD.cxx:412
 AliESD.cxx:413
 AliESD.cxx:414
 AliESD.cxx:415
 AliESD.cxx:416
 AliESD.cxx:417
 AliESD.cxx:418
 AliESD.cxx:419
 AliESD.cxx:420
 AliESD.cxx:421
 AliESD.cxx:422
 AliESD.cxx:423
 AliESD.cxx:424
 AliESD.cxx:425
 AliESD.cxx:426
 AliESD.cxx:427
 AliESD.cxx:428
 AliESD.cxx:429
 AliESD.cxx:430
 AliESD.cxx:431
 AliESD.cxx:432
 AliESD.cxx:433
 AliESD.cxx:434
 AliESD.cxx:435
 AliESD.cxx:436
 AliESD.cxx:437
 AliESD.cxx:438
 AliESD.cxx:439
 AliESD.cxx:440
 AliESD.cxx:441
 AliESD.cxx:442
 AliESD.cxx:443
 AliESD.cxx:444
 AliESD.cxx:445
 AliESD.cxx:446
 AliESD.cxx:447
 AliESD.cxx:448
 AliESD.cxx:449
 AliESD.cxx:450
 AliESD.cxx:451
 AliESD.cxx:452
 AliESD.cxx:453
 AliESD.cxx:454
 AliESD.cxx:455
 AliESD.cxx:456
 AliESD.cxx:457
 AliESD.cxx:458
 AliESD.cxx:459
 AliESD.cxx:460
 AliESD.cxx:461
 AliESD.cxx:462
 AliESD.cxx:463
 AliESD.cxx:464
 AliESD.cxx:465
 AliESD.cxx:466
 AliESD.cxx:467
 AliESD.cxx:468
 AliESD.cxx:469
 AliESD.cxx:470
 AliESD.cxx:471
 AliESD.cxx:472
 AliESD.cxx:473
 AliESD.cxx:474
 AliESD.cxx:475
 AliESD.cxx:476
 AliESD.cxx:477
 AliESD.cxx:478
 AliESD.cxx:479
 AliESD.cxx:480
 AliESD.cxx:481
 AliESD.cxx:482
 AliESD.cxx:483
 AliESD.cxx:484
 AliESD.cxx:485
 AliESD.cxx:486
 AliESD.cxx:487
 AliESD.cxx:488
 AliESD.cxx:489
 AliESD.cxx:490
 AliESD.cxx:491
 AliESD.cxx:492
 AliESD.cxx:493
 AliESD.cxx:494
 AliESD.cxx:495
 AliESD.cxx:496
 AliESD.cxx:497
 AliESD.cxx:498
 AliESD.cxx:499
 AliESD.cxx:500
 AliESD.cxx:501
 AliESD.cxx:502
 AliESD.cxx:503
 AliESD.cxx:504
 AliESD.cxx:505
 AliESD.cxx:506
 AliESD.cxx:507
 AliESD.cxx:508
 AliESD.cxx:509
 AliESD.cxx:510
 AliESD.cxx:511
 AliESD.cxx:512
 AliESD.cxx:513
 AliESD.cxx:514
 AliESD.cxx:515
 AliESD.cxx:516
 AliESD.cxx:517
 AliESD.cxx:518
 AliESD.cxx:519
 AliESD.cxx:520
 AliESD.cxx:521
 AliESD.cxx:522
 AliESD.cxx:523
 AliESD.cxx:524
 AliESD.cxx:525
 AliESD.cxx:526
 AliESD.cxx:527
 AliESD.cxx:528
 AliESD.cxx:529
 AliESD.cxx:530
 AliESD.cxx:531
 AliESD.cxx:532
 AliESD.cxx:533
 AliESD.cxx:534
 AliESD.cxx:535
 AliESD.cxx:536
 AliESD.cxx:537
 AliESD.cxx:538
 AliESD.cxx:539
 AliESD.cxx:540
 AliESD.cxx:541
 AliESD.cxx:542
 AliESD.cxx:543
 AliESD.cxx:544
 AliESD.cxx:545
 AliESD.cxx:546
 AliESD.cxx:547
 AliESD.cxx:548
 AliESD.cxx:549
 AliESD.cxx:550
 AliESD.cxx:551
 AliESD.cxx:552
 AliESD.cxx:553
 AliESD.cxx:554
 AliESD.cxx:555
 AliESD.cxx:556
 AliESD.cxx:557
 AliESD.cxx:558
 AliESD.cxx:559
 AliESD.cxx:560
 AliESD.cxx:561
 AliESD.cxx:562
 AliESD.cxx:563
 AliESD.cxx:564
 AliESD.cxx:565
 AliESD.cxx:566
 AliESD.cxx:567
 AliESD.cxx:568
 AliESD.cxx:569
 AliESD.cxx:570
 AliESD.cxx:571
 AliESD.cxx:572
 AliESD.cxx:573
 AliESD.cxx:574
 AliESD.cxx:575
 AliESD.cxx:576
 AliESD.cxx:577
 AliESD.cxx:578
 AliESD.cxx:579
 AliESD.cxx:580
 AliESD.cxx:581
 AliESD.cxx:582
 AliESD.cxx:583
 AliESD.cxx:584
 AliESD.cxx:585
 AliESD.cxx:586
 AliESD.cxx:587
 AliESD.cxx:588
 AliESD.cxx:589
 AliESD.cxx:590
 AliESD.cxx:591
 AliESD.cxx:592
 AliESD.cxx:593
 AliESD.cxx:594
 AliESD.cxx:595
 AliESD.cxx:596
 AliESD.cxx:597
 AliESD.cxx:598
 AliESD.cxx:599
 AliESD.cxx:600
 AliESD.cxx:601
 AliESD.cxx:602
 AliESD.cxx:603
 AliESD.cxx:604
 AliESD.cxx:605
 AliESD.cxx:606
 AliESD.cxx:607
 AliESD.cxx:608
 AliESD.cxx:609
 AliESD.cxx:610
 AliESD.cxx:611
 AliESD.cxx:612
 AliESD.cxx:613
 AliESD.cxx:614
 AliESD.cxx:615
 AliESD.cxx:616
 AliESD.cxx:617
 AliESD.cxx:618
 AliESD.cxx:619
 AliESD.cxx:620
 AliESD.cxx:621
 AliESD.cxx:622
 AliESD.cxx:623
 AliESD.cxx:624
 AliESD.cxx:625
 AliESD.cxx:626
 AliESD.cxx:627
 AliESD.cxx:628
 AliESD.cxx:629
 AliESD.cxx:630
 AliESD.cxx:631
 AliESD.cxx:632
 AliESD.cxx:633
 AliESD.cxx:634
 AliESD.cxx:635
 AliESD.cxx:636
 AliESD.cxx:637
 AliESD.cxx:638
 AliESD.cxx:639
 AliESD.cxx:640
 AliESD.cxx:641
 AliESD.cxx:642
 AliESD.cxx:643