ROOT logo
/**************************************************************************
 * Copyright(c) 1998-2007, 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$ */

//-------------------------------------------------------------------------
//     AOD base class
//     Author: Markus Oldenburg, CERN
//-------------------------------------------------------------------------

#include <TROOT.h>
#include <TTree.h>
#include <TFolder.h>
#include <TFriendElement.h>
#include <TProcessID.h>
#include <TCollection.h>
#include "Riostream.h"
#include "AliAODEvent.h"
#include "AliAODHeader.h"
#include "AliAODTrack.h"
#include "AliAODDimuon.h"
#include "AliAODTrdTrack.h"

ClassImp(AliAODEvent)

// definition of std AOD member names
  const char* AliAODEvent::fAODListName[kAODListN] = {"header",
						      "tracks",
						      "vertices",
						      "v0s",
						      "cascades",
						      "tracklets",
						      "jets",
						      "emcalCells",
						      "phosCells",
									"caloClusters",
									"emcalTrigger",
									"phosTrigger",
						      "fmdClusters",
						      "pmdClusters",
                                                      "hmpidRings",
						      "dimuons",
						      "AliAODTZERO",
						      "AliAODVZERO",
						      "AliAODZDC",
						      "AliTOFHeader",
						      "trdTracks"
			      						      
};
//______________________________________________________________________________
AliAODEvent::AliAODEvent() :
  AliVEvent(),
  fAODObjects(0),
  fAODFolder(0),
  fConnected(kFALSE),
  fTracksConnected(kFALSE),
  fHeader(0),
  fTracks(0),
  fVertices(0),
  fV0s(0),
  fCascades(0),
  fTracklets(0),
  fJets(0),
  fEmcalCells(0),
  fPhosCells(0),
  fCaloClusters(0),
  fEMCALTrigger(0),
  fPHOSTrigger(0),
  fFmdClusters(0),
  fPmdClusters(0),
  fHMPIDrings(0),
  fDimuons(0),
  fAODTZERO(0),
  fAODVZERO(0),
  fAODZDC(0),
  fTOFHeader(0),
  fTrdTracks(0)
{
  // default constructor
  if (TClass::IsCallingNew() != TClass::kDummyNew) fAODObjects = new TList();
}

//______________________________________________________________________________
AliAODEvent::AliAODEvent(const AliAODEvent& aod):
  AliVEvent(aod),
  fAODObjects(new TList()),
  fAODFolder(0),
  fConnected(kFALSE),
  fTracksConnected(kFALSE),
  //  fHeader(new AliAODHeader(*aod.fHeader)),
  fHeader(0),
  fTracks(new TClonesArray(*aod.fTracks)),
  fVertices(new TClonesArray(*aod.fVertices)),
  fV0s(new TClonesArray(*aod.fV0s)),
  fCascades(new TClonesArray(*aod.fCascades)),
  fTracklets(new AliAODTracklets(*aod.fTracklets)),
  fJets(new TClonesArray(*aod.fJets)),
  fEmcalCells(new AliAODCaloCells(*aod.fEmcalCells)),
  fPhosCells(new AliAODCaloCells(*aod.fPhosCells)),
  fCaloClusters(new TClonesArray(*aod.fCaloClusters)),
  fEMCALTrigger(new AliAODCaloTrigger(*aod.fEMCALTrigger)),
  fPHOSTrigger(new AliAODCaloTrigger(*aod.fPHOSTrigger)),
  fFmdClusters(new TClonesArray(*aod.fFmdClusters)),
  fPmdClusters(new TClonesArray(*aod.fPmdClusters)),
  fHMPIDrings(new TClonesArray(*aod.fHMPIDrings)),
  fDimuons(new TClonesArray(*aod.fDimuons)),
  fAODTZERO(new AliAODTZERO(*aod.fAODTZERO)),
  fAODVZERO(new AliAODVZERO(*aod.fAODVZERO)),
  fAODZDC(new AliAODZDC(*aod.fAODZDC)),
  fTOFHeader(new AliTOFHeader(*aod.fTOFHeader)),
  fTrdTracks(new TClonesArray(*aod.fTrdTracks))
{
  // Copy constructor
  AddHeader(fHeader);
  AddObject(fHeader);
  AddObject(fTracks);
  AddObject(fVertices);
  AddObject(fV0s);
  AddObject(fCascades);
  AddObject(fTracklets);
  AddObject(fJets);
  AddObject(fEmcalCells);
  AddObject(fPhosCells);
  AddObject(fCaloClusters);
  AddObject(fEMCALTrigger);
  AddObject(fPHOSTrigger);
  AddObject(fFmdClusters);
  AddObject(fPmdClusters);
  AddObject(fHMPIDrings);
  AddObject(fDimuons);
  AddObject(fAODTZERO);
  AddObject(fAODVZERO);
  AddObject(fAODZDC);
  AddObject(fTOFHeader);
  AddObject(fTrdTracks);
  fConnected = aod.fConnected;
  ConnectTracks();
  GetStdContent();
  CreateStdFolders();
}

//______________________________________________________________________________
AliAODEvent & AliAODEvent::operator=(const AliAODEvent& aod) {

    // Assignment operator

  if(&aod == this) return *this;
  AliVEvent::operator=(aod);

  // This assumes that the list is already created
  // and that the virtual void Copy(Tobject&) function
  // is correctly implemented in the derived class
  // otherwise only TObject::Copy() will be used

  if((fAODObjects->GetSize()==0)&&(aod.fAODObjects->GetSize()>=kAODListN)){
    // We cover the case that we do not yet have the 
    // standard content but the source has it
    CreateStdContent();
  }
  
  // Here we have the standard content without user additions, but the content is 
  // not matching the aod source.
  
  // Iterate the list of source objects
  TIter next(aod.GetList());
  TObject *its = 0;
  TString name;
  while ((its = next())) {
    name = its->GetName();
    // Check if we have this object type in out list
    TObject *mine = fAODObjects->FindObject(name);    
    if(!mine) {
      // We have to create the same type of object.
      TClass* pClass=TClass::GetClass(its->ClassName());     
      if (!pClass) {
        AliWarning(Form("Can not find class description for entry %s (%s)\n",
                   its->ClassName(), name.Data()));
        continue;
      }
      mine=(TObject*)pClass->New();
      if(!mine){
        // not in this: can be added to list
        AliWarning(Form("%s:%d Could not find %s for copying \n",
                   (char*)__FILE__,__LINE__,name.Data()));
        continue;
      }  
      if(mine->InheritsFrom("TNamed"))	{
        ((TNamed*)mine)->SetName(name);
      } else if(mine->InheritsFrom("TCollection")){
        if(mine->InheritsFrom("TClonesArray")) {
          TClonesArray *itscl = dynamic_cast<TClonesArray*>(its);
          if (!itscl) {
            AliWarning(Form("Class description for entry %s (%s) not TClonesArray\n",
                   its->ClassName(), name.Data()));
            continue;
          
          }
	       dynamic_cast<TClonesArray*>(mine)->SetClass(itscl->GetClass(), itscl->GetSize());
        }
        dynamic_cast<TCollection*>(mine)->SetName(name);
      }
      AliDebug(1, Form("adding object %s of type %s", mine->GetName(), mine->ClassName()));
      AddObject(mine);
    }
    // Now we have an object of the same type and name, but different content.        
    if(!its->InheritsFrom("TCollection")){
      // simple objects (do they have a Copy method that calls operator= ?)
      its->Copy(*mine);
    } else if (its->InheritsFrom("TClonesArray")) {
      // Create or expand the tclonesarray pointers
      // so we can directly copy to the object
      TClonesArray *its_tca = (TClonesArray*)its;
      TClonesArray *mine_tca = (TClonesArray*)mine;
      // this leaves the capacity of the TClonesArray the same
      // except for a factor of 2 increase when size > capacity
      // does not release any memory occupied by the tca
      Int_t its_entries = its_tca->GetEntriesFast();
      mine_tca->ExpandCreate(its_entries);
      for(int i=0; i<its_entries; i++){
        // copy 
        TObject *mine_tca_obj = mine_tca->At(i);
        TObject *its_tca_obj = its_tca->At(i);
        // no need to delete first
        // pointers within the class should be handled by Copy()...
        // Can there be Empty slots?
        its_tca_obj->Copy(*mine_tca_obj);
      }
    } else {
      AliWarning(Form("%s:%d cannot copy TCollection \n",
		      (char*)__FILE__,__LINE__));
    }
  }  
  fConnected = aod.fConnected;
  fTracksConnected = kFALSE;
  ConnectTracks();
  return *this;
}


//______________________________________________________________________________
AliAODEvent::~AliAODEvent() 
{
// destructor
    delete fAODFolder;
    fAODFolder = 0;
    if(!fConnected) {
//       fAODObjects->Delete("slow");
       delete fAODObjects;
    }   
}

//______________________________________________________________________________
void AliAODEvent::AddObject(TObject* obj) 
{
  // Add an object to the list of objects.
  // Please be aware that in order to increase performance you should
  // refrain from using TObjArrays (if possible). Use TClonesArrays, instead.
  
//  if ( !fAODObjects ) {
//     fAODObjects = new TList();
//     fAODObjects->SetOwner();
//  }
  if ( !fAODObjects->FindObject(obj) ) 
  {
    fAODObjects->AddLast(obj);
  }
}

//______________________________________________________________________________
Int_t AliAODEvent::AddTrack(const AliAODTrack* trk)
{
// Add new AOD track. Make sure to set the event if needed.
  AliAODTrack *track =  new((*fTracks)[fTracks->GetEntriesFast()]) AliAODTrack(*trk);
  track->SetAODEvent(this);
  return fTracks->GetEntriesFast()-1;
}  

//______________________________________________________________________________
void AliAODEvent::RemoveObject(TObject* obj) 
{
  // Removes an object from the list of objects.
  
  fAODObjects->Remove(obj);
}

//______________________________________________________________________________
TObject *AliAODEvent::FindListObject(const char *objName) const
{
  // Return the pointer to the object with the given name.

  return fAODObjects->FindObject(objName);
}

//______________________________________________________________________________
void AliAODEvent::CreateStdContent() 
{
  // create the standard AOD content and set pointers

  // create standard objects and add them to the TList of objects
  AddObject(new AliAODHeader());
  AddObject(new TClonesArray("AliAODTrack", 0));
  AddObject(new TClonesArray("AliAODVertex", 0));
  AddObject(new TClonesArray("AliAODv0", 0));
  AddObject(new TClonesArray("AliAODcascade", 0));
  AddObject(new AliAODTracklets());
  AddObject(new TClonesArray("AliAODJet", 0));
  AddObject(new AliAODCaloCells());
  AddObject(new AliAODCaloCells());
  AddObject(new TClonesArray("AliAODCaloCluster", 0));
  AddObject(new AliAODCaloTrigger()); // EMCAL 
  AddObject(new AliAODCaloTrigger()); // PHOS
  AddObject(new TClonesArray("AliAODFmdCluster", 0));
  AddObject(new TClonesArray("AliAODPmdCluster", 0));
  AddObject(new TClonesArray("AliAODHMPIDrings", 0));
  AddObject(new TClonesArray("AliAODDimuon", 0));
  AddObject(new AliAODTZERO());
  AddObject(new AliAODVZERO());
  AddObject(new AliAODZDC());
  AddObject(new AliTOFHeader());
  AddObject(new TClonesArray("AliAODTrdTrack", 0));
  // set names
  SetStdNames();

  // read back pointers
  GetStdContent();
  CreateStdFolders();
  return;
}

void  AliAODEvent::MakeEntriesReferencable()
{
    // Make all entries referencable in a subsequent process
    //
    TIter next(fAODObjects);
    TObject* obj;
    while ((obj = next()))
    {
	if(obj->InheritsFrom("TCollection"))
	    {
		AssignIDtoCollection((TCollection*)obj);
	    }
    }
}

//______________________________________________________________________________
void AliAODEvent::SetStdNames()
{
  // introduce the standard naming

  if(fAODObjects->GetEntries()==kAODListN){
    for(int i = 0;i < fAODObjects->GetEntries();i++){
      TObject *fObj = fAODObjects->At(i);
      if(fObj->InheritsFrom("TNamed")){
	((TNamed*)fObj)->SetName(fAODListName[i]);
      }
      else if(fObj->InheritsFrom("TClonesArray")){
	((TClonesArray*)fObj)->SetName(fAODListName[i]);
      }
    }
  }
  else{
    printf("%s:%d SetStdNames() Wrong number of Std Entries \n",(char*)__FILE__,__LINE__);
  }
} 

//______________________________________________________________________________
void AliAODEvent::CreateStdFolders()
{
    // Create the standard folder structure
  if(fAODFolder)delete fAODFolder;
    fAODFolder = gROOT->GetRootFolder()->AddFolder("AOD", "AOD");
    if(fAODObjects->GetEntries()==kAODListN){
	for(int i = 0;i < fAODObjects->GetEntries();i++){
	    TObject *fObj = fAODObjects->At(i);
	    if(fObj->InheritsFrom("TClonesArray")){
		fAODFolder->AddFolder(fAODListName[i], fAODListName[i], (TCollection*) fObj);
	    } else {
		fAODFolder->AddFolder(fAODListName[i], fAODListName[i], 0);
	    }
	}
    }
    else{
	printf("%s:%d CreateStdFolders() Wrong number of Std Entries \n",(char*)__FILE__,__LINE__);
    }
} 

//______________________________________________________________________________
void AliAODEvent::GetStdContent()
{
  // set pointers for standard content

  fHeader        = (AliVAODHeader*)fAODObjects->FindObject("header");
  fTracks        = (TClonesArray*)fAODObjects->FindObject("tracks");
  fVertices      = (TClonesArray*)fAODObjects->FindObject("vertices");
  fV0s           = (TClonesArray*)fAODObjects->FindObject("v0s");
  fCascades      = (TClonesArray*)fAODObjects->FindObject("cascades");
  fTracklets     = (AliAODTracklets*)fAODObjects->FindObject("tracklets");
  fJets          = (TClonesArray*)fAODObjects->FindObject("jets");
  fEmcalCells    = (AliAODCaloCells*)fAODObjects->FindObject("emcalCells");
  fPhosCells     = (AliAODCaloCells*)fAODObjects->FindObject("phosCells");
  fCaloClusters  = (TClonesArray*)fAODObjects->FindObject("caloClusters");
  fEMCALTrigger  = (AliAODCaloTrigger*)fAODObjects->FindObject("emcalTrigger");
  fPHOSTrigger   = (AliAODCaloTrigger*)fAODObjects->FindObject("phosTrigger");
  fFmdClusters   = (TClonesArray*)fAODObjects->FindObject("fmdClusters");
  fPmdClusters   = (TClonesArray*)fAODObjects->FindObject("pmdClusters");
  fHMPIDrings    = (TClonesArray*)fAODObjects->FindObject("hmpidRings");  
  fDimuons       = (TClonesArray*)fAODObjects->FindObject("dimuons");
  fAODTZERO      = (AliAODTZERO*)fAODObjects->FindObject("AliAODTZERO");
  fAODVZERO      = (AliAODVZERO*)fAODObjects->FindObject("AliAODVZERO");
  fAODZDC        = (AliAODZDC*)fAODObjects->FindObject("AliAODZDC");
  fTOFHeader     = (AliTOFHeader*)fAODObjects->FindObject("AliTOFHeader");
  fTrdTracks     = (TClonesArray*)fAODObjects->FindObject("trdTracks");
}

//______________________________________________________________________________
void AliAODEvent::ResetStd(Int_t trkArrSize, 
            Int_t vtxArrSize, 
            Int_t v0ArrSize,
            Int_t cascadeArrSize,
            Int_t jetSize, 
            Int_t caloClusSize, 
            Int_t fmdClusSize, 
            Int_t pmdClusSize,
            Int_t hmpidRingsSize,
            Int_t dimuonArrSize,
            Int_t nTrdTracks
			   )
{
  // deletes content of standard arrays and resets size 
  fTracksConnected = kFALSE;
  if (fTracks) {
    fTracks->Delete();
    if (trkArrSize > fTracks->GetSize()) 
      fTracks->Expand(trkArrSize);
  }
  if (fVertices) {
    fVertices->Delete();
    if (vtxArrSize > fVertices->GetSize()) 
      fVertices->Expand(vtxArrSize);
  }
  if (fV0s) {
    fV0s->Delete();
    if (v0ArrSize > fV0s->GetSize()) 
      fV0s->Expand(v0ArrSize);
  }
  if (fCascades) {
    fCascades->Delete();
    if (cascadeArrSize > fCascades->GetSize()) 
      fCascades->Expand(cascadeArrSize);
  }
  if (fJets) {
    fJets->Delete();
    if (jetSize > fJets->GetSize())
      fJets->Expand(jetSize);
  }
  if (fCaloClusters) {
    fCaloClusters->Delete();
    if (caloClusSize > fCaloClusters->GetSize()) 
      fCaloClusters->Expand(caloClusSize);
  }
  if (fFmdClusters) {
    fFmdClusters->Delete();
    if (fmdClusSize > fFmdClusters->GetSize()) 
      fFmdClusters->Expand(fmdClusSize);
  }
  if (fPmdClusters) {
    fPmdClusters->Delete();
    if (pmdClusSize > fPmdClusters->GetSize()) 
      fPmdClusters->Expand(pmdClusSize);
  }
  if (fHMPIDrings) {
     fHMPIDrings->Delete();
    if (hmpidRingsSize > fHMPIDrings->GetSize()) 
      fHMPIDrings->Expand(hmpidRingsSize);
  }
  if (fDimuons) {
    fDimuons->Delete();
    if (dimuonArrSize > fDimuons->GetSize()) 
      fDimuons->Expand(dimuonArrSize);
  }
  if (fTrdTracks) {
    // no pointers in there, so cheaper Clear suffices
//    fTrdTracks->Clear("C");
    // Not quite: AliAODTrdTrack has a clones array of tracklets inside
    fTrdTracks->Delete();
    if (nTrdTracks > fTrdTracks->GetSize())
      fTrdTracks->Expand(nTrdTracks);
  }

  if (fTracklets)
    fTracklets->DeleteContainer();
  if (fPhosCells)
    fPhosCells->DeleteContainer();  
  if (fEmcalCells)
    fEmcalCells->DeleteContainer();
  
  if (fEMCALTrigger)
	fEMCALTrigger->DeAllocate();
  if (fPHOSTrigger)
	fPHOSTrigger->DeAllocate();

}

//______________________________________________________________________________
void AliAODEvent::ClearStd()
{
  // clears the standard arrays
  if (fHeader){
    // FIXME: this if-else patch was introduced by Michele Floris on 17/03/14 to test nano AOD. To be removed.
    if(fHeader->InheritsFrom("AliAODHeader")){
      fHeader        ->Clear();
    }
    else {
      AliVHeader * head = 0;
      head = dynamic_cast<AliVHeader*>((TObject*)fHeader);
      if(head) head->Clear();
    }
  }
  fTracksConnected = kFALSE;
  if (fTracks)
    fTracks        ->Delete();
  if (fVertices)
    fVertices      ->Delete();
  if (fV0s)
    fV0s           ->Delete();
  if (fCascades)
    fCascades      ->Delete();
  if (fTracklets)
    fTracklets     ->DeleteContainer();
  if (fJets)
    fJets          ->Delete();
  if (fEmcalCells)
    fEmcalCells    ->DeleteContainer();
  if (fPhosCells)
    fPhosCells     ->DeleteContainer();
  if (fCaloClusters)
    fCaloClusters  ->Delete();
  if (fFmdClusters)
    fFmdClusters   ->Clear();
  if (fPmdClusters)
    fPmdClusters   ->Clear();  
  if (fHMPIDrings) 
     fHMPIDrings   ->Clear();    
  if (fDimuons)
    fDimuons       ->Clear();
  if (fTrdTracks)
    fTrdTracks     ->Clear();
	
  if (fEMCALTrigger)
	fEMCALTrigger->DeAllocate();
  if (fPHOSTrigger)
	fPHOSTrigger->DeAllocate();
}

//_________________________________________________________________
Int_t AliAODEvent::GetPHOSClusters(TRefArray *clusters) const
{
  // fills the provided TRefArray with all found phos clusters
  
  clusters->Clear();
  
  AliAODCaloCluster *cl = 0;
  Bool_t first = kTRUE;
  for (Int_t i = 0; i < GetNumberOfCaloClusters() ; i++) {
    if ( (cl = GetCaloCluster(i)) ) {
      if (cl->IsPHOS()){
	if(first) {
	  new (clusters) TRefArray(TProcessID::GetProcessWithUID(cl)); 
	  first=kFALSE;
	}
	clusters->Add(cl);
	//printf("IsPHOS cluster %d, E %2.3f Size: %d \n",i,cl->E(),clusters->GetEntriesFast());
      }
    }
  }
  return clusters->GetEntriesFast();
}

//_________________________________________________________________
Int_t AliAODEvent::GetEMCALClusters(TRefArray *clusters) const
{
  // fills the provided TRefArray with all found emcal clusters

  clusters->Clear();
  AliAODCaloCluster *cl = 0;
  Bool_t first = kTRUE;
  for (Int_t i = 0; i < GetNumberOfCaloClusters(); i++) {
    if ( (cl = GetCaloCluster(i)) ) {
      if (cl->IsEMCAL()){
	if(first) {
	  new (clusters) TRefArray(TProcessID::GetProcessWithUID(cl)); 
	  first=kFALSE;
	}
	clusters->Add(cl);
	//printf("IsEMCal cluster %d, E %2.3f Size: %d \n",i,cl->E(),clusters->GetEntriesFast());
      }
    }
  }
  return clusters->GetEntriesFast();
}


//______________________________________________________________________________
Int_t AliAODEvent::GetMuonTracks(TRefArray *muonTracks) const
{
  // fills the provided TRefArray with all found muon tracks

  muonTracks->Clear();

  AliAODTrack *track = 0;
  for (Int_t iTrack = 0; iTrack < GetNumberOfTracks(); iTrack++) {
    track = dynamic_cast<AliAODTrack*>(GetTrack(iTrack));
    if(!track) AliFatal("Not a standard AOD");
    if (track->IsMuonTrack()) {
      muonTracks->Add(track);
    }
  }
  
  return muonTracks->GetEntriesFast();
}


//______________________________________________________________________________
Int_t AliAODEvent::GetNumberOfMuonTracks() const
{
  // get number of muon tracks
  Int_t nMuonTracks=0;
   
  if(!dynamic_cast<AliAODTrack*>(GetTrack(0))) {
    AliError("Not a standard AOD");
    return 0;
  }

  for (Int_t iTrack = 0; iTrack < GetNumberOfTracks(); iTrack++) {
    if (((AliAODTrack*)GetTrack(iTrack))->IsMuonTrack()) {
       nMuonTracks++;
    }
  }
  
  return nMuonTracks;
}

//______________________________________________________________________________
Int_t AliAODEvent::GetMuonGlobalTracks(TRefArray *muonGlobalTracks) const           // AU
{
  // fills the provided TRefArray with all found muon global tracks

  muonGlobalTracks->Clear();

  AliAODTrack *track = 0;
  for (Int_t iTrack = 0; iTrack < GetNumberOfTracks(); iTrack++) {
    track = dynamic_cast<AliAODTrack*>(GetTrack(iTrack));
    if(!track) AliFatal("Not a standard AOD");
    if (track->IsMuonGlobalTrack()) {
      muonGlobalTracks->Add(track);
    }
  }
  
  return muonGlobalTracks->GetEntriesFast();
}


//______________________________________________________________________________
Int_t AliAODEvent::GetNumberOfMuonGlobalTracks() const                                    // AU
{
  // get number of muon global tracks
  Int_t nMuonGlobalTracks=0;
  if(!dynamic_cast<AliAODTrack*>(GetTrack(0))) {
    AliError("Not a standard AOD");
    return 0;
  }
  for (Int_t iTrack = 0; iTrack < GetNumberOfTracks(); iTrack++) {
    if (((AliAODTrack*)GetTrack(iTrack))->IsMuonGlobalTrack()) {
       nMuonGlobalTracks++;
    }
  }
  
  return nMuonGlobalTracks;
}

//______________________________________________________________________________
void AliAODEvent::ReadFromTree(TTree *tree, Option_t* opt /*= ""*/)
{
    // Connects aod event to tree
  
  if(!tree){
    AliWarning("Zero Pointer to Tree \n");
    return;
  }
    // load the TTree
  if(!tree->GetTree())tree->LoadTree(0);
  
    // Try to find AliAODEvent
  AliAODEvent *aodEvent = 0;
  aodEvent = (AliAODEvent*)tree->GetTree()->GetUserInfo()->FindObject("AliAODEvent");
  if(aodEvent){
    // This event is connected to the tree by definition, just say so
    aodEvent->SetConnected();
      // Check if already connected to tree
    TList* connectedList = (TList*) (tree->GetUserInfo()->FindObject("AODObjectsConnectedToTree"));
    if (connectedList && (!strcmp(opt, "reconnect"))) {
        // If connected use the connected list of objects
        if (fAODObjects != connectedList) {
           delete fAODObjects;
           fAODObjects = connectedList;
        }   
        GetStdContent(); 
        fConnected = kTRUE;
        return;
    } 
      // Connect to tree
      // prevent a memory leak when reading back the TList
//      if (!(strcmp(opt, "reconnect"))) fAODObjects->Delete();
    
      // create a new TList from the UserInfo TList... 
      // copy constructor does not work...
    //    fAODObjects = (TList*)(aodEvent->GetList()->Clone());
    fAODObjects = (TList*)aodEvent->GetList();
    fAODObjects->SetOwner(kTRUE);
    if(fAODObjects->GetEntries()<kAODListN)
    {
      AliWarning(Form("AliAODEvent::ReadFromTree() TList contains less than the standard contents %d < %d"
                      " That might be fine though (at least for filtered AODs)",fAODObjects->GetEntries(),kAODListN));
    }
      //
      // Let's find out whether we have friends
    TList* friendL = tree->GetTree()->GetListOfFriends();
    if (friendL) 
    {
      TIter next(friendL);
      TFriendElement* fe;
      while ((fe = (TFriendElement*)next())){
        aodEvent = (AliAODEvent*)(fe->GetTree()->GetUserInfo()->FindObject("AliAODEvent"));
        if (!aodEvent) {
          printf("No UserInfo on tree \n");
        } else {
          
	  //          TList* objL = (TList*)(aodEvent->GetList()->Clone());
          TList* objL = (TList*)aodEvent->GetList();
          printf("Get list of object from tree %d !!\n", objL->GetEntries());
          TIter nextobject(objL);
          TObject* obj =  0;
          while((obj = nextobject()))
          {
            printf("Adding object from friend %s !\n", obj->GetName());
            fAODObjects->Add(obj);
          } // object "branch" loop
        } // has userinfo  
      } // friend loop
    } // has friends	
      // set the branch addresses
    TIter next(fAODObjects);
    TNamed *el;
    while((el=(TNamed*)next())){
      TString bname(el->GetName());
        // check if branch exists under this Name
      TBranch *br = tree->GetTree()->GetBranch(bname.Data());
      if(br){
        tree->SetBranchAddress(bname.Data(),fAODObjects->GetObjectRef(el));
      } else {
        br = tree->GetBranch(Form("%s.",bname.Data()));
        if(br){
          tree->SetBranchAddress(Form("%s.",bname.Data()),fAODObjects->GetObjectRef(el));
        }
        else{
          printf("%s %d AliAODEvent::ReadFromTree() No Branch found with Name %s. \n",
                 (char*)__FILE__,__LINE__,bname.Data());
        }	
      }
    }
    GetStdContent();
      // when reading back we are not owner of the list 
      // must not delete it
    fAODObjects->SetOwner(kTRUE);
    fAODObjects->SetName("AODObjectsConnectedToTree");
      // we are not owner of the list objects 
      // must not delete it
    tree->GetUserInfo()->Add(fAODObjects);
    fConnected = kTRUE;
  }// no aodEvent
  else {
      // we can't get the list from the user data, create standard content
      // and set it by hand
    CreateStdContent();
    TIter next(fAODObjects);
    TNamed *el;
    while((el=(TNamed*)next())){
      TString bname(el->GetName());    
      tree->SetBranchAddress(bname.Data(),fAODObjects->GetObjectRef(el));
    }
    GetStdContent();
      // when reading back we are not owner of the list 
      // must not delete it
    fAODObjects->SetOwner(kTRUE);
  }
}
  //______________________________________________________________________________
Int_t  AliAODEvent::GetNumberOfPileupVerticesSPD() const{
  // count number of SPD pileup vertices
  Int_t nVertices=GetNumberOfVertices();
  Int_t nPileupVertices=0;
  for(Int_t iVert=0; iVert<nVertices; iVert++){
    AliAODVertex *v=GetVertex(iVert);
    if(v->GetType()==AliAODVertex::kPileupSPD) nPileupVertices++;
  }
  return nPileupVertices;
}
//______________________________________________________________________________
Int_t  AliAODEvent::GetNumberOfPileupVerticesTracks() const{
  // count number of track pileup vertices
  Int_t nVertices=GetNumberOfVertices();
  Int_t nPileupVertices=0;
  for(Int_t iVert=0; iVert<nVertices; iVert++){
    AliAODVertex *v=GetVertex(iVert);
    if(v->GetType()==AliAODVertex::kPileupTracks) nPileupVertices++;
  }
  return nPileupVertices;
}
//______________________________________________________________________________
AliAODVertex* AliAODEvent::GetPrimaryVertexSPD() const{
  // Get SPD primary vertex
  Int_t nVertices=GetNumberOfVertices();
  for(Int_t iVert=0; iVert<nVertices; iVert++){
    AliAODVertex *v=GetVertex(iVert);
    if(v->GetType()==AliAODVertex::kMainSPD) return v;
  }
  return 0;
}
//______________________________________________________________________________
AliAODVertex* AliAODEvent::GetPrimaryVertexTPC() const{
  // Get SPD primary vertex
  Int_t nVertices=GetNumberOfVertices();
  for(Int_t iVert=0; iVert<nVertices; iVert++){
    AliAODVertex *v=GetVertex(iVert);
    if(v->GetType()==AliAODVertex::kMainTPC) return v;
  }
  return 0;
}
//______________________________________________________________________________
AliAODVertex* AliAODEvent::GetPileupVertexSPD(Int_t iV) const{
  // Get pile-up vertex iV
  Int_t nVertices=GetNumberOfVertices();
  Int_t counter=0;
  for(Int_t iVert=0; iVert<nVertices; iVert++){
    AliAODVertex *v=GetVertex(iVert);
    if(v->GetType()==AliAODVertex::kPileupSPD){
      if(counter==iV) return v;
      ++counter;
    }
  }
  return 0;
}
//______________________________________________________________________________
AliAODVertex* AliAODEvent::GetPileupVertexTracks(Int_t iV) const{
  // Get pile-up vertex iV
  Int_t nVertices=GetNumberOfVertices();
  Int_t counter=0;
  for(Int_t iVert=0; iVert<nVertices; iVert++){
    AliAODVertex *v=GetVertex(iVert);
    if(v->GetType()==AliAODVertex::kPileupTracks){
      if(counter==iV) return v;
      ++counter;
    }
  }
  return 0;
}
//______________________________________________________________________________
Bool_t  AliAODEvent::IsPileupFromSPD(Int_t minContributors, 
				     Double_t minZdist, 
				     Double_t nSigmaZdist, 
				     Double_t nSigmaDiamXY, 
				     Double_t nSigmaDiamZ) const{
  //
  // This function checks if there was a pile up
  // reconstructed with SPD
  //
  AliAODVertex *mainV=GetPrimaryVertexSPD();
  if(!mainV) return kFALSE;
  Int_t nc1=mainV->GetNContributors();
  if(nc1<1) return kFALSE;
  Int_t nPileVert=GetNumberOfPileupVerticesSPD();
  if(nPileVert==0) return kFALSE;
  Int_t nVertices=GetNumberOfVertices();
  
  for(Int_t iVert=0; iVert<nVertices; iVert++){
    AliAODVertex *pv=GetVertex(iVert);
    if(pv->GetType()!=AliAODVertex::kPileupSPD) continue;
    Int_t nc2=pv->GetNContributors();
    if(nc2>=minContributors){
      Double_t z1=mainV->GetZ();
      Double_t z2=pv->GetZ();
      Double_t distZ=TMath::Abs(z2-z1);
      Double_t distZdiam=TMath::Abs(z2-GetDiamondZ());
      Double_t cutZdiam=nSigmaDiamZ*TMath::Sqrt(GetSigma2DiamondZ());
      if(GetSigma2DiamondZ()<0.0001)cutZdiam=99999.; //protection for missing z diamond information
      if(distZ>minZdist && distZdiam<cutZdiam){
	Double_t x2=pv->GetX();
	Double_t y2=pv->GetY();
	Double_t distXdiam=TMath::Abs(x2-GetDiamondX());
	Double_t distYdiam=TMath::Abs(y2-GetDiamondY());
	Double_t cov1[6],cov2[6];	
	mainV->GetCovarianceMatrix(cov1);
	pv->GetCovarianceMatrix(cov2);
	Double_t errxDist=TMath::Sqrt(cov2[0]+GetSigma2DiamondX());
	Double_t erryDist=TMath::Sqrt(cov2[2]+GetSigma2DiamondY());
	Double_t errzDist=TMath::Sqrt(cov1[5]+cov2[5]);
	Double_t cutXdiam=nSigmaDiamXY*errxDist;
	if(GetSigma2DiamondX()<0.0001)cutXdiam=99999.; //protection for missing diamond information
	Double_t cutYdiam=nSigmaDiamXY*erryDist;
	if(GetSigma2DiamondY()<0.0001)cutYdiam=99999.; //protection for missing diamond information
	if( (distXdiam<cutXdiam) && (distYdiam<cutYdiam) && (distZ>nSigmaZdist*errzDist) ){
	  return kTRUE;
	}
      }
    }
  }
  return kFALSE;
}

//______________________________________________________________________________
void AliAODEvent::Print(Option_t *) const
{
  // Print the names of the all branches
  TIter next(fAODObjects);
  TNamed *el;
  Printf(">>>>>  AOD  Content <<<<<");    
  while((el=(TNamed*)next())){
    Printf(">> %s ",el->GetName());      
  }
  Printf(">>>>>                <<<<<");    
  
  return;
}

//______________________________________________________________________________
void AliAODEvent::AssignIDtoCollection(const TCollection* col)
{
    // Static method which assigns a ID to each object in a collection
    // In this way the objects are marked as referenced and written with 
    // an ID. This has the advantage that TRefs to this objects can be 
    // written by a subsequent process.
    TIter next(col);
    TObject* obj;
    while ((obj = next()))
	TProcessID::AssignID(obj);
}

//______________________________________________________________________________
Bool_t AliAODEvent::IsPileupFromSPDInMultBins() const {
    Int_t nTracklets=GetTracklets()->GetNumberOfTracklets();
    if(nTracklets<20) return IsPileupFromSPD(3,0.8);
    else if(nTracklets<50) return IsPileupFromSPD(4,0.8);
    else return IsPileupFromSPD(5,0.8);
}

//______________________________________________________________________________
void AliAODEvent::Reset()
{
  // Handle the cases
  // Std content + Non std content

  ClearStd();
  if(fAODObjects->GetSize()>kAODListN){
    // we have non std content
    // this also covers aodfriends
    for(int i = kAODListN;i < fAODObjects->GetSize();++i){
      TObject *pObject = fAODObjects->At(i);
      // TClonesArrays
      if(pObject->InheritsFrom(TClonesArray::Class())){
       ((TClonesArray*)pObject)->Delete();
      }
      else if(!pObject->InheritsFrom(TCollection::Class())){
       TClass *pClass = TClass::GetClass(pObject->ClassName());
       if (pClass && pClass->GetListOfMethods()->FindObject("Clear")) {
         AliDebug(1, Form("Clear for object %s class %s", pObject->GetName(), pObject->ClassName()));
         pObject->Clear();
       }
       else {
         AliDebug(1, Form("ResetWithPlacementNew for object %s class %s", pObject->GetName(), pObject->ClassName()));
          Long_t dtoronly = TObject::GetDtorOnly();
          TObject::SetDtorOnly(pObject);
          delete pObject;
          pClass->New(pObject);
          TObject::SetDtorOnly((void*)dtoronly);
       }
      }
      else{
       AliWarning(Form("No reset for %s \n",
                       pObject->ClassName()));
      }
    }
  }
}

// FIXME: Why is this in event and not in header?
Float_t AliAODEvent::GetVZEROEqMultiplicity(Int_t i) const
{
  // Get VZERO Multiplicity for channel i
  // Themethod uses the equalization factors
  // stored in the ESD-run object in order to
  // get equal multiplicities within a VZERO rins (1/8 of VZERO)
  if (!fAODVZERO || !fHeader) return -1;

  Int_t ring = i/8;
  Float_t factorSum = 0;
  for(Int_t j = 8*ring; j < (8*ring+8); ++j) {
    factorSum += fHeader->GetVZEROEqFactors(j);
  }
  Float_t factor = fHeader->GetVZEROEqFactors(i)*8./factorSum;

  return (fAODVZERO->GetMultiplicity(i)/factor);
}

//------------------------------------------------------------
void  AliAODEvent::SetTOFHeader(const AliTOFHeader *header)
{
  //
  // Set the TOF event_time
  //

  if (fTOFHeader) {
    *fTOFHeader=*header;
    //fTOFHeader->SetName(fgkESDListName[kTOFHeader]);
  }
  else {
    // for analysis of reconstructed events
    // when this information is not avaliable
    fTOFHeader = new AliTOFHeader(*header);
    //AddObject(fTOFHeader);
  }

}
//------------------------------------------------------------
AliAODHMPIDrings *AliAODEvent::GetHMPIDringForTrackID(Int_t trackID) const
{
  //
  // Returns the HMPID object if any for a given track ID
  //
  if(GetHMPIDrings())
  {
    for(Int_t ien = 0 ; ien < GetNHMPIDrings(); ien++)
    {
      if( GetHMPIDring(ien)->GetHmpTrkID() == trackID ) return GetHMPIDring(ien);      
    }//rings loop  
  }
  return 0;
}
//------------------------------------------------------------
Int_t AliAODEvent::GetNHMPIDrings() const   
{ 
  //
  // If there is a list of HMPID rings in the given AOD event, return their number
  //
  if ( fHMPIDrings) return fHMPIDrings->GetEntriesFast(); 
  else return -1;
} 
//------------------------------------------------------------
AliAODHMPIDrings *AliAODEvent::GetHMPIDring(Int_t nRings) const
{ 
  //
  // If there is a list of HMPID rings in the given AOD event, return corresponding ring
  //
  if(fHMPIDrings) {
    if(   (AliAODHMPIDrings*)fHMPIDrings->UncheckedAt(nRings) ) {
      return (AliAODHMPIDrings*)fHMPIDrings->UncheckedAt(nRings);
    }
    else return 0x0;
  }
  else return 0x0;  
}
//------------------------------------------------------------
AliAODTrdTrack& AliAODEvent::AddTrdTrack(const AliVTrdTrack *track) {
  return *(new ((*fTrdTracks)[fTrdTracks->GetEntriesFast()]) AliAODTrdTrack(*track));
}

//______________________________________________________________________________
void AliAODEvent::ConnectTracks() {
// Connect tracks to this event
  if (fTracksConnected || !fTracks || !fTracks->GetEntriesFast()) return;
  AliAODTrack *track = 0;
  track = dynamic_cast<AliAODTrack*>(GetTrack(0));
  if(!track) {
    AliWarning("Not an AliAODTrack, this is not a standard AOD"); 
    return;
  }

  TIter next(fTracks);
  while ((track=(AliAODTrack*)next())) track->SetAODEvent(this);
  fTracksConnected = kTRUE;
}

AliVEvent::EDataLayoutType AliAODEvent::GetDataLayoutType() const {return AliVEvent::kAOD;}

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