ESD and AOD tracks contain a transient pointer to the event to which they belong...
authoragheata <Andrei.Gheata@cern.ch>
Tue, 4 Feb 2014 14:46:26 +0000 (15:46 +0100)
committeragheata <Andrei.Gheata@cern.ch>
Tue, 4 Feb 2014 15:19:12 +0000 (16:19 +0100)
ANALYSIS/ESDfilter/AliAnalysisTaskESDfilter.cxx
STEER/AOD/AliAODEvent.cxx
STEER/AOD/AliAODEvent.h
STEER/AOD/AliAODInputHandler.cxx
STEER/AOD/AliAODTrack.h
STEER/ESD/AliESDEvent.cxx
STEER/ESD/AliESDEvent.h
STEER/ESD/AliESDInputHandler.cxx
STEER/ESD/AliESDtrack.h
STEER/STEERBase/AliVTrack.h

index 994e6b7..fca0f55 100644 (file)
@@ -2194,7 +2194,9 @@ void AliAnalysisTaskESDfilter::ConvertESDtoAOD()
   // loop over events and fill them
   // Multiplicity information needed by the header (to be revised!)
   Int_t nTracks    = esd->GetNumberOfTracks();
-  for (Int_t iTrack=0; iTrack<nTracks; ++iTrack) esd->GetTrack(iTrack)->SetESDEvent(esd);
+
+// The line below should not be needed anymore (tracks already connected)
+//  for (Int_t iTrack=0; iTrack<nTracks; ++iTrack) esd->GetTrack(iTrack)->SetESDEvent(esd);
 
   // Update the header
   Int_t nV0s      = esd->GetNumberOfV0s();
index c0f71b4..c4efafe 100644 (file)
@@ -65,6 +65,7 @@ AliAODEvent::AliAODEvent() :
   fAODObjects(0),
   fAODFolder(0),
   fConnected(kFALSE),
+  fTracksConnected(kFALSE),
   fHeader(0),
   fTracks(0),
   fVertices(0),
@@ -97,6 +98,7 @@ AliAODEvent::AliAODEvent(const AliAODEvent& aod):
   fAODObjects(new TList()),
   fAODFolder(0),
   fConnected(kFALSE),
+  fTracksConnected(kFALSE),
   fHeader(new AliAODHeader(*aod.fHeader)),
   fTracks(new TClonesArray(*aod.fTracks)),
   fVertices(new TClonesArray(*aod.fVertices)),
@@ -142,6 +144,7 @@ AliAODEvent::AliAODEvent(const AliAODEvent& aod):
   AddObject(fTOFHeader);
   AddObject(fTrdTracks);
   fConnected = aod.fConnected;
+  ConnectTracks();
   GetStdContent();
   CreateStdFolders();
 }
@@ -238,6 +241,8 @@ AliAODEvent & AliAODEvent::operator=(const AliAODEvent& aod) {
     }
   }  
   fConnected = aod.fConnected;
+  fTracksConnected = kFALSE;
+  ConnectTracks();
   return *this;
 }
 
@@ -272,6 +277,15 @@ void AliAODEvent::AddObject(TObject* 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.
@@ -359,6 +373,7 @@ void AliAODEvent::SetStdNames()
   }
 } 
 
+//______________________________________________________________________________
 void AliAODEvent::CreateStdFolders()
 {
     // Create the standard folder structure
@@ -409,19 +424,20 @@ void AliAODEvent::GetStdContent()
 
 //______________________________________________________________________________
 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
+            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()) 
@@ -493,11 +509,13 @@ void AliAODEvent::ResetStd(Int_t trkArrSize,
 
 }
 
+//______________________________________________________________________________
 void AliAODEvent::ClearStd()
 {
   // clears the standard arrays
   if (fHeader)
     fHeader        ->Clear();
+  fTracksConnected = kFALSE;
   if (fTracks)
     fTracks        ->Delete();
   if (fVertices)
@@ -858,6 +876,7 @@ void AliAODEvent::Print(Option_t *) const
   return;
 }
 
+//______________________________________________________________________________
 void AliAODEvent::AssignIDtoCollection(const TCollection* col)
 {
     // Static method which assigns a ID to each object in a collection
@@ -870,6 +889,7 @@ void AliAODEvent::AssignIDtoCollection(const TCollection* col)
        TProcessID::AssignID(obj);
 }
 
+//______________________________________________________________________________
 Bool_t AliAODEvent::IsPileupFromSPDInMultBins() const {
     Int_t nTracklets=GetTracklets()->GetNumberOfTracklets();
     if(nTracklets<20) return IsPileupFromSPD(3,0.8);
@@ -877,13 +897,13 @@ Bool_t AliAODEvent::IsPileupFromSPDInMultBins() const {
     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
@@ -995,3 +1015,14 @@ AliAODHMPIDrings *AliAODEvent::GetHMPIDring(Int_t nRings) const
 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;
+  TIter next(fTracks);
+  while ((track=(AliAODTrack*)next())) track->SetAODEvent(this);
+  fTracksConnected = kTRUE;
+}
+
index 2ae5677..2b6e39e 100644 (file)
@@ -81,6 +81,7 @@ class AliAODEvent : public AliVEvent {
   TList        *GetList()                const { return fAODObjects; }
   void          SetConnected(Bool_t conn=kTRUE) {fConnected=conn;}
   Bool_t        GetConnected() const {return fConnected;}
+  Bool_t        AreTracksConnected() const {return fTracksConnected;}
 
   // -- Header
   AliAODHeader *GetHeader()              const { return fHeader; }
@@ -139,11 +140,11 @@ class AliAODEvent : public AliVEvent {
 
   // -- Tracks
   TClonesArray *GetTracks()              const { return fTracks; }
+  void          ConnectTracks();
   Int_t         GetNTracks()             const { return fTracks? fTracks->GetEntriesFast() : 0; }
   Int_t         GetNumberOfTracks()      const { return GetNTracks(); }
-  AliAODTrack  *GetTrack(Int_t nTrack)   const { if(fTracks && fTracks->UncheckedAt(nTrack)) ((AliAODTrack*)fTracks->UncheckedAt(nTrack))->SetAODEvent(this);return fTracks ? (AliAODTrack*)fTracks->UncheckedAt(nTrack):0; }
-  Int_t         AddTrack(const AliAODTrack* trk)
-    {new((*fTracks)[fTracks->GetEntriesFast()]) AliAODTrack(*trk); return fTracks->GetEntriesFast()-1;}
+  AliAODTrack  *GetTrack(Int_t nTrack)   const { return fTracks ? (AliAODTrack*)fTracks->UncheckedAt(nTrack):0; }
+  Int_t         AddTrack(const AliAODTrack* trk);
   Int_t         GetMuonTracks(TRefArray *muonTracks) const;
   Int_t         GetNumberOfMuonTracks() const;
 
@@ -312,6 +313,7 @@ class AliAODEvent : public AliVEvent {
   TList   *fAODObjects; //  list of AODObjects
   TFolder *fAODFolder;  //  folder structure of branches
   Bool_t   fConnected;  //! flag if leaves are alreday connected 
+  Bool_t   fTracksConnected;      //! flag if tracks have already pointer to event set
   // standard content
   AliAODHeader    *fHeader;       //! event information
   TClonesArray    *fTracks;       //! charged tracks
index 62c17ef..915b36e 100644 (file)
@@ -146,7 +146,10 @@ Bool_t AliAODInputHandler::BeginEvent(Long64_t entry)
       fIsSelectedResult = fEvent->GetHeader()->GetOfflineTrigger();
 
     if (fMixingHandler) fMixingHandler->BeginEvent(entry);
-    
+
+    // set transient pointer to event inside tracks
+    fEvent->ConnectTracks();
+
     return kTRUE;
 }
 
index df3524a..b2cc6b9 100644 (file)
@@ -333,6 +333,7 @@ class AliAODTrack : public AliVTrack {
   void      GetHMPIDpid(Double_t */*p*/) const { return; } // TODO: To be implemented properly with the new HMPID object
 
   const AliAODEvent* GetAODEvent() const {return fAODEvent;}
+  virtual const AliVEvent* GetEvent() const {return (AliVEvent*)fAODEvent;}
   void SetAODEvent(const AliAODEvent* ptr){fAODEvent = ptr;}
   const AliTOFHeader* GetTOFHeader() const;
 
@@ -471,7 +472,7 @@ class AliAODTrack : public AliVTrack {
   Double_t      fTPCsignalTuned;    //! TPC signal tuned on data when using MC
   Double_t      fTOFsignalTuned;    //! TOF signal tuned on data when using MC
 
-  const AliAODEvent* fAODEvent;     //! 
+  const AliAODEvent* fAODEvent;     //! pointer back to the event the track belongs to
 
   ClassDef(AliAODTrack, 23);
 };
index 5f72ac6..de0c3a6 100644 (file)
@@ -159,6 +159,7 @@ AliESDEvent::AliESDEvent():
   fESDFriendOld(0),
   fConnected(kFALSE),
   fUseOwnList(kFALSE),
+  fTracksConnected(kFALSE),
   fTOFHeader(0),
   fCentrality(0),
   fEventplane(0),
@@ -210,6 +211,7 @@ AliESDEvent::AliESDEvent(const AliESDEvent& esd):
   fESDFriendOld(esd.fESDFriendOld ? new AliESDfriend(*esd.fESDFriendOld) : 0),
   fConnected(esd.fConnected),
   fUseOwnList(esd.fUseOwnList),
+  fTracksConnected(kFALSE),
   fTOFHeader(new AliTOFHeader(*esd.fTOFHeader)),
   fCentrality(new AliCentrality(*esd.fCentrality)),
   fEventplane(new AliEventplane(*esd.fEventplane)),
@@ -256,6 +258,7 @@ AliESDEvent::AliESDEvent(const AliESDEvent& esd):
   AddObject(fMuonClusters);
   AddObject(fMuonPads);
   GetStdContent();
+  ConnectTracks();
 }
 
 //______________________________________________________________________________
@@ -352,7 +355,7 @@ AliESDEvent & AliESDEvent::operator=(const AliESDEvent& source) {
 
   fConnected  = source.fConnected;
   fUseOwnList = source.fUseOwnList;
-  
+
   fDetectorStatus = source.fDetectorStatus;
   fDAQDetectorPattern = source.fDAQDetectorPattern;
   fDAQAttributes = source.fDAQAttributes;
@@ -360,7 +363,8 @@ AliESDEvent & AliESDEvent::operator=(const AliESDEvent& source) {
 
   *fTOFcluster = *source.fTOFcluster;
   //  fTOFcluster = new TObjArray(*(source.fTOFcluster));
-
+  fTracksConnected = kFALSE;
+  ConnectTracks();
   return *this;
 }
 
@@ -452,6 +456,7 @@ void AliESDEvent::Reset()
 
 }
 
+//______________________________________________________________________________
 Bool_t AliESDEvent::ResetWithPlacementNew(TObject *pObject){
   //
   // funtion to reset using the already allocated space
@@ -467,6 +472,7 @@ Bool_t AliESDEvent::ResetWithPlacementNew(TObject *pObject){
   return kTRUE;
 }
 
+//______________________________________________________________________________
 void AliESDEvent::ResetStdContent()
 {
   // Reset the standard contents
@@ -529,6 +535,7 @@ void AliESDEvent::ResetStdContent()
   if(fEMCALTrigger)fEMCALTrigger->DeAllocate(); 
   if(fSPDPileupVertices)fSPDPileupVertices->Delete();
   if(fTrkPileupVertices)fTrkPileupVertices->Delete();
+  fTracksConnected = kFALSE;
   if(fTracks)fTracks->Delete();
   if(fMuonTracks)fMuonTracks->Clear("C");
   if(fMuonClusters)fMuonClusters->Clear("C");
@@ -550,6 +557,7 @@ void AliESDEvent::ResetStdContent()
 }
 
 
+//______________________________________________________________________________
 Int_t AliESDEvent::AddV0(const AliESDv0 *v) {
   //
   // Add V0
@@ -634,10 +642,12 @@ void AliESDEvent::Print(Option_t *) const
   return;
 }
 
-void AliESDEvent::SetESDfriend(const AliESDfriend *ev) const {
-  //
-  // Attaches the complementary info to the ESD
-  //
+//______________________________________________________________________________
+void AliESDEvent::SetESDfriend(const AliESDfriend *ev) const 
+{
+//
+// Attaches the complementary info to the ESD
+//
   if (!ev) return;
 
   // to be sure that we set the tracks also
@@ -653,23 +663,27 @@ void AliESDEvent::SetESDfriend(const AliESDfriend *ev) const {
   }
 }
 
-Bool_t  AliESDEvent::RemoveKink(Int_t rm) const {
-  // ---------------------------------------------------------
-  // Remove a kink candidate and references to it from ESD,
-  // if this candidate does not come from a reconstructed decay
-  // Not yet implemented...
-  // ---------------------------------------------------------
+//______________________________________________________________________________
+Bool_t  AliESDEvent::RemoveKink(Int_t rm) const 
+{
+// ---------------------------------------------------------
+// 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  AliESDEvent::RemoveV0(Int_t rm) const {
-  // ---------------------------------------------------------
-  // Remove a V0 candidate and references to it from ESD,
-  // if this candidate does not come from a reconstructed decay
-  // ---------------------------------------------------------
+//______________________________________________________________________________
+Bool_t  AliESDEvent::RemoveV0(Int_t rm) const 
+{
+// ---------------------------------------------------------
+// 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;
 
@@ -729,11 +743,13 @@ Bool_t  AliESDEvent::RemoveV0(Int_t rm) const {
   return kTRUE;
 }
 
-Bool_t  AliESDEvent::RemoveTrack(Int_t rm) const {
-  // ---------------------------------------------------------
-  // Remove a track and references to it from ESD,
-  // if this track does not come from a reconstructed decay
-  // ---------------------------------------------------------
+//______________________________________________________________________________
+Bool_t  AliESDEvent::RemoveTrack(Int_t rm) const 
+{
+// ---------------------------------------------------------
+// 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;
 
@@ -928,8 +944,9 @@ Bool_t  AliESDEvent::RemoveTrack(Int_t rm) const {
   return kTRUE;
 }
 
-
-Bool_t AliESDEvent::Clean(Float_t *cleanPars) {
+//______________________________________________________________________________
+Bool_t AliESDEvent::Clean(Float_t *cleanPars) 
+{
   //
   // Remove the data which are not needed for the physics analysis.
   //
@@ -993,6 +1010,7 @@ Bool_t AliESDEvent::Clean(Float_t *cleanPars) {
   return rc;
 }
 
+//______________________________________________________________________________
 Char_t  AliESDEvent::AddPileupVertexSPD(const AliESDVertex *vtx) 
 {
     // Add a pileup primary vertex reconstructed with SPD
@@ -1003,6 +1021,7 @@ Char_t  AliESDEvent::AddPileupVertexSPD(const AliESDVertex *vtx)
     return n;
 }
 
+//______________________________________________________________________________
 Char_t  AliESDEvent::AddPileupVertexTracks(const AliESDVertex *vtx) 
 {
     // Add a pileup primary vertex reconstructed with SPD
@@ -1013,21 +1032,25 @@ Char_t  AliESDEvent::AddPileupVertexTracks(const AliESDVertex *vtx)
     return n;
 }
 
+//______________________________________________________________________________
 Int_t  AliESDEvent::AddTrack(const AliESDtrack *t) 
 {
     // Add track
     TClonesArray &ftr = *fTracks;
     AliESDtrack * track = new(ftr[fTracks->GetEntriesFast()])AliESDtrack(*t);
     track->SetID(fTracks->GetEntriesFast()-1);
+    track->SetESDEvent(this);
     return  track->GetID();    
 }
 
+//______________________________________________________________________________
 AliESDtrack*  AliESDEvent::NewTrack() 
 {
     // Add a new track
     TClonesArray &ftr = *fTracks;
     AliESDtrack * track = new(ftr[fTracks->GetEntriesFast()])AliESDtrack();
     track->SetID(fTracks->GetEntriesFast()-1);
+    track->SetESDEvent(this);
     return  track;
 }
 
@@ -1178,49 +1201,57 @@ AliESDMuonPad* AliESDEvent::NewMuonPad()
   return new(fmu[fMuonPads->GetEntriesFast()]) AliESDMuonPad();
 }
 
+//______________________________________________________________________________
 void AliESDEvent::AddPmdTrack(const AliESDPmdTrack *t) 
 {
   TClonesArray &fpmd = *fPmdTracks;
   new(fpmd[fPmdTracks->GetEntriesFast()]) AliESDPmdTrack(*t);
 }
 
+//______________________________________________________________________________
 void AliESDEvent::SetTrdTrigger(const AliESDTrdTrigger *t)
 {
   *fTrdTrigger = *t;
 }
 
+//______________________________________________________________________________
 void AliESDEvent::AddTrdTrack(const AliESDTrdTrack *t) 
 {
   TClonesArray &ftrd = *fTrdTracks;
   new(ftrd[fTrdTracks->GetEntriesFast()]) AliESDTrdTrack(*t);
 }
 
+//______________________________________________________________________________
 void AliESDEvent::AddTrdTracklet(const AliESDTrdTracklet *trkl)
 {
   new ((*fTrdTracklets)[fTrdTracklets->GetEntriesFast()]) AliESDTrdTracklet(*trkl);
 }
 
+//______________________________________________________________________________
 void AliESDEvent::AddTrdTracklet(UInt_t trackletWord, Short_t hcid, Int_t label)
 {
   new ((*fTrdTracklets)[fTrdTracklets->GetEntriesFast()]) AliESDTrdTracklet(trackletWord, hcid, label);
 }
 
+//______________________________________________________________________________
 Int_t AliESDEvent::AddKink(const AliESDkink *c) 
 {
-    // Add kink
-    TClonesArray &fk = *fKinks;
-    AliESDkink * kink = new(fk[fKinks->GetEntriesFast()]) AliESDkink(*c);
-    kink->SetID(fKinks->GetEntriesFast()); // CKB different from the other imps..
-    return fKinks->GetEntriesFast()-1;
+  // Add kink
+  TClonesArray &fk = *fKinks;
+  AliESDkink * kink = new(fk[fKinks->GetEntriesFast()]) AliESDkink(*c);
+  kink->SetID(fKinks->GetEntriesFast()); // CKB different from the other imps..
+  return fKinks->GetEntriesFast()-1;
 }
 
 
+//______________________________________________________________________________
 void AliESDEvent::AddCascade(const AliESDcascade *c) 
 {
   TClonesArray &fc = *fCascades;
   new(fc[fCascades->GetEntriesFast()]) AliESDcascade(*c);
 }
 
+//______________________________________________________________________________
 void AliESDEvent::AddCosmicTrack(const AliESDCosmicTrack *t) 
 {
   TClonesArray &ft = *fCosmicTracks;
@@ -1228,21 +1259,24 @@ void AliESDEvent::AddCosmicTrack(const AliESDCosmicTrack *t)
 } 
 
 
+//______________________________________________________________________________
 Int_t AliESDEvent::AddCaloCluster(const AliESDCaloCluster *c) 
 {
-    // Add calocluster
-    TClonesArray &fc = *fCaloClusters;
-    AliESDCaloCluster *clus = new(fc[fCaloClusters->GetEntriesFast()]) AliESDCaloCluster(*c);
-    clus->SetID(fCaloClusters->GetEntriesFast()-1);
-    return fCaloClusters->GetEntriesFast()-1;
-  }
+  // Add calocluster
+  TClonesArray &fc = *fCaloClusters;
+  AliESDCaloCluster *clus = new(fc[fCaloClusters->GetEntriesFast()]) AliESDCaloCluster(*c);
+  clus->SetID(fCaloClusters->GetEntriesFast()-1);
+  return fCaloClusters->GetEntriesFast()-1;
+}
 
 
+//______________________________________________________________________________
 void  AliESDEvent::AddRawDataErrorLog(const AliRawDataErrorLog *log) const {
   TClonesArray &errlogs = *fErrorLogs;
   new(errlogs[errlogs.GetEntriesFast()])  AliRawDataErrorLog(*log);
 }
 
+//______________________________________________________________________________
 void AliESDEvent::SetZDCData(const AliESDZDC * obj)
 { 
   // use already allocated space
@@ -1250,6 +1284,7 @@ void AliESDEvent::SetZDCData(const AliESDZDC * obj)
     *fESDZDC = *obj;
 }
 
+//______________________________________________________________________________
 void  AliESDEvent::SetPrimaryVertexTPC(const AliESDVertex *vertex) 
 {
   // Set the TPC vertex
@@ -1260,6 +1295,7 @@ void  AliESDEvent::SetPrimaryVertexTPC(const AliESDVertex *vertex)
   }
 }
 
+//______________________________________________________________________________
 void  AliESDEvent::SetPrimaryVertexSPD(const AliESDVertex *vertex) 
 {
   // Set the SPD vertex
@@ -1270,6 +1306,7 @@ void  AliESDEvent::SetPrimaryVertexSPD(const AliESDVertex *vertex)
   }
 }
 
+//______________________________________________________________________________
 void  AliESDEvent::SetPrimaryVertexTracks(const AliESDVertex *vertex) 
 {
   // Set the primary vertex reconstructed using he ESD tracks.
@@ -1280,6 +1317,7 @@ void  AliESDEvent::SetPrimaryVertexTracks(const AliESDVertex *vertex)
   }
 }
 
+//______________________________________________________________________________
 const AliESDVertex * AliESDEvent::GetPrimaryVertex() const 
 {
   //
@@ -1297,6 +1335,7 @@ const AliESDVertex * AliESDEvent::GetPrimaryVertex() const
   return fSPDVertex;
 }
 
+//______________________________________________________________________________
 AliESDVertex * AliESDEvent::PrimaryVertexTracksUnconstrained() const 
 {
   //
@@ -1322,6 +1361,7 @@ AliESDVertex * AliESDEvent::PrimaryVertexTracksUnconstrained() const
   return vertex;
 }
 
+//______________________________________________________________________________
 void AliESDEvent::SetMultiplicity(const AliMultiplicity *mul) 
 {
   // Set the SPD Multiplicity
@@ -1331,6 +1371,7 @@ void AliESDEvent::SetMultiplicity(const AliMultiplicity *mul)
 }
 
 
+//______________________________________________________________________________
 void AliESDEvent::SetFMDData(AliESDFMD * obj) 
 { 
   // use already allocated space
@@ -1339,6 +1380,7 @@ void AliESDEvent::SetFMDData(AliESDFMD * obj)
   }
 }
 
+//______________________________________________________________________________
 void AliESDEvent::SetVZEROData(const AliESDVZERO * obj)
 { 
   // use already allocated space
@@ -1346,6 +1388,7 @@ void AliESDEvent::SetVZEROData(const AliESDVZERO * obj)
     *fESDVZERO = *obj;
 }
 
+//______________________________________________________________________________
 void AliESDEvent::SetTZEROData(const AliESDTZERO * obj)
 { 
   // use already allocated space
@@ -1354,20 +1397,21 @@ void AliESDEvent::SetTZEROData(const AliESDTZERO * obj)
 }
 
 
+//______________________________________________________________________________
 void AliESDEvent::SetACORDEData(AliESDACORDE * obj)
 {
   if(fESDACORDE)
     *fESDACORDE = *obj;
 }
 
+//______________________________________________________________________________
 void AliESDEvent::SetADData(AliESDAD * obj)
 {
   if(fESDAD)
     *fESDAD = *obj;
 }
 
-
-
+//______________________________________________________________________________
 void AliESDEvent::GetESDfriend(AliESDfriend *ev) const 
 {
   //
@@ -1391,6 +1435,7 @@ void AliESDEvent::GetESDfriend(AliESDfriend *ev) const
   if (fr) ev->SetVZEROfriend(fr->GetVZEROfriend());
 }
 
+//______________________________________________________________________________
 void AliESDEvent::AddObject(TObject* obj) 
 {
   // Add an object to the list of object.
@@ -1400,7 +1445,7 @@ void AliESDEvent::AddObject(TObject* obj)
   fESDObjects->AddLast(obj);
 }
 
-
+//______________________________________________________________________________
 void AliESDEvent::GetStdContent() 
 {
   // set pointers for standard content
@@ -1442,6 +1487,7 @@ void AliESDEvent::GetStdContent()
   fTOFcluster = new TObjArray(1);
 }
 
+//______________________________________________________________________________
 void AliESDEvent::SetStdNames(){
   // Set the names of the standard contents
   // 
@@ -1461,12 +1507,13 @@ void AliESDEvent::SetStdNames(){
   }
 } 
 
-
+//______________________________________________________________________________
 void AliESDEvent::CreateStdContent(Bool_t bUseThisList){
   fUseOwnList = bUseThisList;
   CreateStdContent();
 }
 
+//______________________________________________________________________________
 void AliESDEvent::CreateStdContent() 
 {
   // create the standard AOD content and set pointers
@@ -1514,6 +1561,7 @@ void AliESDEvent::CreateStdContent()
   GetStdContent();
 }
 
+//______________________________________________________________________________
 void AliESDEvent::CompleteStdContent() 
 {
   // Create missing standard objects and add them to the TList of objects
@@ -1540,6 +1588,7 @@ void AliESDEvent::CompleteStdContent()
   }
 }
 
+//______________________________________________________________________________
 TObject* AliESDEvent::FindListObject(const char *name) const {
 //
 // Find object with name "name" in the list of branches
@@ -1550,6 +1599,7 @@ TObject* AliESDEvent::FindListObject(const char *name) const {
   return 0;
 } 
 
+//______________________________________________________________________________
 Int_t AliESDEvent::GetPHOSClusters(TRefArray *clusters) const
 {
   // fills the provided TRefArray with all found phos clusters
@@ -1569,6 +1619,7 @@ Int_t AliESDEvent::GetPHOSClusters(TRefArray *clusters) const
   return clusters->GetEntriesFast();
 }
 
+//______________________________________________________________________________
 Int_t AliESDEvent::GetEMCALClusters(TRefArray *clusters) const
 {
   // fills the provided TRefArray with all found emcal clusters
@@ -1588,6 +1639,7 @@ Int_t AliESDEvent::GetEMCALClusters(TRefArray *clusters) const
   return clusters->GetEntriesFast();
 }
 
+//______________________________________________________________________________
 void AliESDEvent::WriteToTree(TTree* tree) const {
   // Book the branches as in TTree::Branch(TCollection*)
   // but add a "." at the end of top level branches which are
@@ -1621,7 +1673,7 @@ void AliESDEvent::WriteToTree(TTree* tree) const {
   tree->Branch("fTOFcluster","TObjArray",(void *) &fTOFcluster);
 }
 
-
+//______________________________________________________________________________
 void AliESDEvent::ReadFromTree(TTree *tree, Option_t* opt){
 //
 // Connect the ESDEvent to a tree
@@ -1840,7 +1892,7 @@ void AliESDEvent::ReadFromTree(TTree *tree, Option_t* opt){
   }
 }
 
-
+//______________________________________________________________________________
 void AliESDEvent::CopyFromOldESD()
 {
   // Method which copies over everthing from the old esd structure to the 
@@ -1935,6 +1987,7 @@ void AliESDEvent::CopyFromOldESD()
   }// if fesdold
 }
 
+//______________________________________________________________________________
 Bool_t AliESDEvent::IsEventSelected(const char *trigExpr) const
 {
   // Check if the event satisfies the trigger
@@ -1966,6 +2019,7 @@ Bool_t AliESDEvent::IsEventSelected(const char *trigExpr) const
 
 }
 
+//______________________________________________________________________________
 TObject*  AliESDEvent::GetHLTTriggerDecision() const
 {
   // get the HLT trigger decission object
@@ -1988,6 +2042,7 @@ TString   AliESDEvent::GetHLTTriggerDescription() const
   return description;
 }
 
+//______________________________________________________________________________
 Bool_t    AliESDEvent::IsHLTTriggerFired(const char* name) const
 {
   // get the HLT trigger decission description
@@ -2096,6 +2151,7 @@ void AliESDEvent::EstimateMultiplicity(Int_t &tracklets, Int_t &trITSTPC, Int_t
   //
 }
 
+//______________________________________________________________________________
 Bool_t AliESDEvent::IsPileupFromSPDInMultBins() const {
     Int_t nTracklets=GetMultiplicity()->GetNumberOfTracklets();
     if(nTracklets<20) return IsPileupFromSPD(3,0.8);
@@ -2103,6 +2159,7 @@ Bool_t AliESDEvent::IsPileupFromSPDInMultBins() const {
     else return IsPileupFromSPD(5,0.8);
 }
 
+//______________________________________________________________________________
 void  AliESDEvent::SetTOFHeader(const AliTOFHeader *header)
 {
   //
@@ -2122,18 +2179,21 @@ void  AliESDEvent::SetTOFHeader(const AliTOFHeader *header)
 
 }
 
+//______________________________________________________________________________
 AliCentrality* AliESDEvent::GetCentrality()
 {
     if (!fCentrality) fCentrality = new AliCentrality();
     return  fCentrality;
 }
 
+//______________________________________________________________________________
 AliEventplane* AliESDEvent::GetEventplane()
 {
     if (!fEventplane) fEventplane = new AliEventplane();
     return  fEventplane;
 }
 
+//______________________________________________________________________________
 Float_t AliESDEvent::GetVZEROEqMultiplicity(Int_t i) const
 {
   // Get VZERO Multiplicity for channel i
@@ -2152,6 +2212,7 @@ Float_t AliESDEvent::GetVZEROEqMultiplicity(Int_t i) const
   return (fESDVZERO->GetMultiplicity(i)/factor);
 }
 
+//______________________________________________________________________________
 void AliESDEvent::SetTOFcluster(Int_t ntofclusters,AliESDTOFcluster *cluster,Int_t *mapping){
   fNTOFclusters = 0;
 
@@ -2173,6 +2234,8 @@ void AliESDEvent::SetTOFcluster(Int_t ntofclusters,AliESDTOFcluster *cluster,Int
    
 
 }
+
+//______________________________________________________________________________
 void AliESDEvent::SetTOFcluster(Int_t ntofclusters,AliESDTOFcluster *cluster[],Int_t *mapping){
   fNTOFclusters = 0;
 
@@ -2194,3 +2257,13 @@ void AliESDEvent::SetTOFcluster(Int_t ntofclusters,AliESDTOFcluster *cluster[],I
    
 
 }
+
+//______________________________________________________________________________
+void AliESDEvent::ConnectTracks() {
+// Connect tracks to this event
+  if (fTracksConnected || !fTracks || !fTracks->GetEntriesFast()) return;
+  AliESDtrack *track;
+  TIter next(fTracks);
+  while ((track=(AliESDtrack*)next())) track->SetESDEvent(this);
+  fTracksConnected = kTRUE;
+}
index b16fd19..6b31e88 100644 (file)
@@ -327,12 +327,10 @@ public:
   
   virtual Bool_t IsPileupFromSPDInMultBins() const;
 
-  AliESDtrack *GetTrack(Int_t i) const {
-    if (!fTracks) return 0;
-    AliESDtrack* track = (AliESDtrack*) fTracks->At(i);
-    if (track) track->SetESDEvent(this);
-    return track;
-  }
+  void ConnectTracks();
+  Bool_t        AreTracksConnected() const {return fTracksConnected;}
+
+  AliESDtrack *GetTrack(Int_t i) const {return (fTracks)?(AliESDtrack*)fTracks->At(i) : 0;}
   Int_t  AddTrack(const AliESDtrack *t);
 
   /// add new track at the end of tracks array and return instance
@@ -560,6 +558,7 @@ protected:
   AliESDfriend *fESDFriendOld;     //! Old friend esd Structure
   Bool_t    fConnected;            //! flag if leaves are alreday connected
   Bool_t    fUseOwnList;           //! Do not use the list from the esdTree but use the one created by this class 
+  Bool_t    fTracksConnected;      //! flag if tracks have already pointer to event set
 
   static const char* fgkESDListName[kESDListN]; //!
 
index 8bcac36..28ee6eb 100644 (file)
@@ -142,6 +142,9 @@ Bool_t AliESDInputHandler::BeginEvent(Long64_t entry)
   ((AliESDEvent*)fEvent)->SetESDfriend(fFriend);
   called = kTRUE;
 
+  // set transient pointer to event inside tracks
+  fEvent->ConnectTracks();
+
   if (fMixingHandler) fMixingHandler->BeginEvent(entry);
   if (fUseTags && fRunTag) {
     fEventTag = 0;
index 87ee990..e250a70 100644 (file)
@@ -420,6 +420,7 @@ public:
   virtual void Print(Option_t * opt) const ;
   const AliESDEvent* GetESDEvent() const {return fESDEvent;}
   const AliTOFHeader* GetTOFHeader() const;
+  const AliVEvent* GetEvent() const {return (AliVEvent*)fESDEvent;}
   void         SetESDEvent(const AliESDEvent* evt) {fESDEvent = evt;}
 
   // Trasient PID object, is owned by the track
index 072095c..4da6985 100644 (file)
@@ -13,6 +13,7 @@
 
 #include "AliVParticle.h"
 
+class AliVEvent;
 class AliVVertex;
 class AliExternalTrackParam;
 class AliTPCdEdxInfo;
@@ -68,6 +69,7 @@ public:
   AliVTrack(const AliVTrack& vTrack); 
   AliVTrack& operator=(const AliVTrack& vTrack);
 
+  virtual const AliVEvent* GetEvent() const {return 0;}
   virtual Int_t    GetID() const = 0;
   virtual UChar_t  GetITSClusterMap() const = 0;
   virtual void     GetITSdEdxSamples(Double_t s[4]) const {for (int i=4;i--;) s[i]=0;};