HMPID related updates
[u/mrichter/AliRoot.git] / STEER / AOD / AliAODEvent.cxx
1 /**************************************************************************
2  * Copyright(c) 1998-2007, ALICE Experiment at CERN, All rights reserved. *
3  *                                                                        *
4  * Author: The ALICE Off-line Project.                                    *
5  * Contributors are mentioned in the code where appropriate.              *
6  *                                                                        *
7  * Permission to use, copy, modify and distribute this software and its   *
8  * documentation strictly for non-commercial purposes is hereby granted   *
9  * without fee, provided that the above copyright notice appears in all   *
10  * copies and that both the copyright notice and this permission notice   *
11  * appear in the supporting documentation. The authors make no claims     *
12  * about the suitability of this software for any purpose. It is          *
13  * provided "as is" without express or implied warranty.                  *
14  **************************************************************************/
15
16 /* $Id$ */
17
18 //-------------------------------------------------------------------------
19 //     AOD base class
20 //     Author: Markus Oldenburg, CERN
21 //-------------------------------------------------------------------------
22
23 #include <TROOT.h>
24 #include <TTree.h>
25 #include <TFolder.h>
26 #include <TFriendElement.h>
27 #include <TProcessID.h>
28 #include <TCollection.h>
29 #include "Riostream.h"
30 #include "AliAODEvent.h"
31 #include "AliAODHeader.h"
32 #include "AliAODTrack.h"
33 #include "AliAODDimuon.h"
34
35 ClassImp(AliAODEvent)
36
37 // definition of std AOD member names
38   const char* AliAODEvent::fAODListName[kAODListN] = {"header",
39                                                       "tracks",
40                                                       "vertices",
41                                                       "v0s",
42                                                       "cascades",
43                                                       "tracklets",
44                                                       "jets",
45                                                       "emcalCells",
46                                                       "phosCells",
47                                                                         "caloClusters",
48                                                                         "emcalTrigger",
49                                                                         "phosTrigger",
50                                                       "fmdClusters",
51                                                       "pmdClusters",
52                                                       "hmpidRings",
53                                                       "dimuons",
54                                                       "AliAODTZERO",
55                                                       "AliAODVZERO",
56                                                       "AliAODZDC",
57                                                       "AliTOFHeader"
58 #ifdef MFT_UPGRADE        
59                                                       ,"AliAODMFT"
60 #endif                                                
61                                                       
62 };
63 //______________________________________________________________________________
64 AliAODEvent::AliAODEvent() :
65   AliVEvent(),
66   fAODObjects(0),
67   fAODFolder(0),
68   fConnected(kFALSE),
69   fHeader(0),
70   fTracks(0),
71   fVertices(0),
72   fV0s(0),
73   fCascades(0),
74   fTracklets(0),
75   fJets(0),
76   fEmcalCells(0),
77   fPhosCells(0),
78   fCaloClusters(0),
79   fEMCALTrigger(0),
80   fPHOSTrigger(0),
81   fFmdClusters(0),
82   fPmdClusters(0),
83   fHMPIDrings(0),
84   fDimuons(0),
85   fAODTZERO(0),
86   fAODVZERO(0),
87   fAODZDC(0),
88   fTOFHeader(0)
89 #ifdef MFT_UPGRADE
90   ,fAODMFT(0)
91 #endif
92 {
93   // default constructor
94   if (TClass::IsCallingNew() != TClass::kDummyNew) fAODObjects = new TList();
95 }
96
97 //______________________________________________________________________________
98 AliAODEvent::AliAODEvent(const AliAODEvent& aod):
99   AliVEvent(aod),
100   fAODObjects(new TList()),
101   fAODFolder(0),
102   fConnected(kFALSE),
103   fHeader(new AliAODHeader(*aod.fHeader)),
104   fTracks(new TClonesArray(*aod.fTracks)),
105   fVertices(new TClonesArray(*aod.fVertices)),
106   fV0s(new TClonesArray(*aod.fV0s)),
107   fCascades(new TClonesArray(*aod.fCascades)),
108   fTracklets(new AliAODTracklets(*aod.fTracklets)),
109   fJets(new TClonesArray(*aod.fJets)),
110   fEmcalCells(new AliAODCaloCells(*aod.fEmcalCells)),
111   fPhosCells(new AliAODCaloCells(*aod.fPhosCells)),
112   fCaloClusters(new TClonesArray(*aod.fCaloClusters)),
113   fEMCALTrigger(new AliAODCaloTrigger(*aod.fEMCALTrigger)),
114   fPHOSTrigger(new AliAODCaloTrigger(*aod.fPHOSTrigger)),
115   fFmdClusters(new TClonesArray(*aod.fFmdClusters)),
116   fPmdClusters(new TClonesArray(*aod.fPmdClusters)),
117   fHMPIDrings(new TClonesArray(*aod.fHMPIDrings)),
118   fDimuons(new TClonesArray(*aod.fDimuons)),
119   fAODTZERO(new AliAODTZERO(*aod.fAODTZERO)),
120   fAODVZERO(new AliAODVZERO(*aod.fAODVZERO)),
121   fAODZDC(new AliAODZDC(*aod.fAODZDC)),
122   fTOFHeader(new AliTOFHeader(*aod.fTOFHeader))
123 #ifdef MFT_UPGRADE
124   ,fAODMFT(new AliAODMFT(*aod.fAODMFT))
125 #endif
126 {
127   // Copy constructor
128   AddObject(fHeader);
129   AddObject(fTracks);
130   AddObject(fVertices);
131   AddObject(fV0s);
132   AddObject(fCascades);
133   AddObject(fTracklets);
134   AddObject(fJets);
135   AddObject(fEmcalCells);
136   AddObject(fPhosCells);
137   AddObject(fCaloClusters);
138   AddObject(fEMCALTrigger);
139   AddObject(fPHOSTrigger);
140   AddObject(fFmdClusters);
141   AddObject(fPmdClusters);
142   AddObject(fHMPIDrings);
143   AddObject(fDimuons);
144   AddObject(fAODTZERO);
145   AddObject(fAODVZERO);
146   AddObject(fAODZDC);
147   AddObject(fTOFHeader);
148 #ifdef MFT_UPGRADE      
149   AddObject(fAODVZERO);
150 #endif
151   fConnected = aod.fConnected;
152   GetStdContent();
153   CreateStdFolders();
154 }
155
156 //______________________________________________________________________________
157 AliAODEvent & AliAODEvent::operator=(const AliAODEvent& aod) {
158
159     // Assignment operator
160
161   if(&aod == this) return *this;
162   AliVEvent::operator=(aod);
163
164   // This assumes that the list is already created
165   // and that the virtual void Copy(Tobject&) function
166   // is correctly implemented in the derived class
167   // otherwise only TObject::Copy() will be used
168
169   if((fAODObjects->GetSize()==0)&&(aod.fAODObjects->GetSize()>=kAODListN)){
170     // We cover the case that we do not yet have the 
171     // standard content but the source has it
172     CreateStdContent();
173   }
174   
175   // Here we have the standard content without user additions, but the content is 
176   // not matching the aod source.
177   
178   // Iterate the list of source objects
179   TIter next(aod.GetList());
180   TObject *its = 0;
181   TString name;
182   while ((its = next())) {
183     name = its->GetName();
184     // Check if we have this object type in out list
185     TObject *mine = fAODObjects->FindObject(name);    
186     if(!mine) {
187       // We have to create the same type of object.
188       TClass* pClass=TClass::GetClass(its->ClassName());     
189       if (!pClass) {
190         AliWarning(Form("Can not find class description for entry %s (%s)\n",
191                    its->ClassName(), name.Data()));
192         continue;
193       }
194       mine=(TObject*)pClass->New();
195       if(!mine){
196         // not in this: can be added to list
197         AliWarning(Form("%s:%d Could not find %s for copying \n",
198                    (char*)__FILE__,__LINE__,name.Data()));
199         continue;
200       }  
201       if(mine->InheritsFrom("TNamed"))  {
202         ((TNamed*)mine)->SetName(name);
203       } else if(mine->InheritsFrom("TCollection")){
204         if(mine->InheritsFrom("TClonesArray")) {
205           TClonesArray *itscl = dynamic_cast<TClonesArray*>(its);
206           if (!itscl) {
207             AliWarning(Form("Class description for entry %s (%s) not TClonesArray\n",
208                    its->ClassName(), name.Data()));
209             continue;
210           
211           }
212                dynamic_cast<TClonesArray*>(mine)->SetClass(itscl->GetClass(), itscl->GetSize());
213         }
214         dynamic_cast<TCollection*>(mine)->SetName(name);
215       }
216       AliDebug(1, Form("adding object %s of type %s", mine->GetName(), mine->ClassName()));
217       AddObject(mine);
218     }
219     // Now we have an object of the same type and name, but different content.        
220     if(!its->InheritsFrom("TCollection")){
221       // simple objects (do they have a Copy method that calls operator= ?)
222       its->Copy(*mine);
223     } else if (its->InheritsFrom("TClonesArray")) {
224       // Create or expand the tclonesarray pointers
225       // so we can directly copy to the object
226       TClonesArray *its_tca = (TClonesArray*)its;
227       TClonesArray *mine_tca = (TClonesArray*)mine;
228       // this leaves the capacity of the TClonesArray the same
229       // except for a factor of 2 increase when size > capacity
230       // does not release any memory occupied by the tca
231       Int_t its_entries = its_tca->GetEntriesFast();
232       mine_tca->ExpandCreate(its_entries);
233       for(int i=0; i<its_entries; i++){
234         // copy 
235         TObject *mine_tca_obj = mine_tca->At(i);
236         TObject *its_tca_obj = its_tca->At(i);
237         // no need to delete first
238         // pointers within the class should be handled by Copy()...
239         // Can there be Empty slots?
240         its_tca_obj->Copy(*mine_tca_obj);
241       }
242     } else {
243       AliWarning(Form("%s:%d cannot copy TCollection \n",
244                       (char*)__FILE__,__LINE__));
245     }
246   }  
247   fConnected = aod.fConnected;
248   return *this;
249 }
250
251
252 //______________________________________________________________________________
253 AliAODEvent::~AliAODEvent() 
254 {
255 // destructor
256     delete fAODFolder;
257     fAODFolder = 0;
258     if(!fConnected) {
259 //       fAODObjects->Delete("slow");
260        delete fAODObjects;
261     }   
262 }
263
264 //______________________________________________________________________________
265 void AliAODEvent::AddObject(TObject* obj) 
266 {
267   // Add an object to the list of objects.
268   // Please be aware that in order to increase performance you should
269   // refrain from using TObjArrays (if possible). Use TClonesArrays, instead.
270   
271 //  if ( !fAODObjects ) {
272 //     fAODObjects = new TList();
273 //     fAODObjects->SetOwner();
274 //  }
275   if ( !fAODObjects->FindObject(obj) ) 
276   {
277     fAODObjects->AddLast(obj);
278   }
279 }
280
281 //______________________________________________________________________________
282 void AliAODEvent::RemoveObject(TObject* obj) 
283 {
284   // Removes an object from the list of objects.
285   
286   fAODObjects->Remove(obj);
287 }
288
289 //______________________________________________________________________________
290 TObject *AliAODEvent::FindListObject(const char *objName) const
291 {
292   // Return the pointer to the object with the given name.
293
294   return fAODObjects->FindObject(objName);
295 }
296
297 //______________________________________________________________________________
298 void AliAODEvent::CreateStdContent() 
299 {
300   // create the standard AOD content and set pointers
301
302   // create standard objects and add them to the TList of objects
303   AddObject(new AliAODHeader());
304   AddObject(new TClonesArray("AliAODTrack", 0));
305   AddObject(new TClonesArray("AliAODVertex", 0));
306   AddObject(new TClonesArray("AliAODv0", 0));
307   AddObject(new TClonesArray("AliAODcascade", 0));
308   AddObject(new AliAODTracklets());
309   AddObject(new TClonesArray("AliAODJet", 0));
310   AddObject(new AliAODCaloCells());
311   AddObject(new AliAODCaloCells());
312   AddObject(new TClonesArray("AliAODCaloCluster", 0));
313   AddObject(new AliAODCaloTrigger()); // EMCAL 
314   AddObject(new AliAODCaloTrigger()); // PHOS
315   AddObject(new TClonesArray("AliAODFmdCluster", 0));
316   AddObject(new TClonesArray("AliAODPmdCluster", 0));
317   AddObject(new TClonesArray("AliAODHMPIDrings", 0));
318   AddObject(new TClonesArray("AliAODDimuon", 0));
319   AddObject(new AliAODTZERO());
320   AddObject(new AliAODVZERO());
321   AddObject(new AliAODZDC());
322   AddObject(new AliTOFHeader());
323 #ifdef MFT_UPGRADE
324   AddObject(new AliAODMFT());
325 #endif
326   // set names
327   SetStdNames();
328
329   // read back pointers
330   GetStdContent();
331   CreateStdFolders();
332   return;
333 }
334
335 void  AliAODEvent::MakeEntriesReferencable()
336 {
337     // Make all entries referencable in a subsequent process
338     //
339     TIter next(fAODObjects);
340     TObject* obj;
341     while ((obj = next()))
342     {
343         if(obj->InheritsFrom("TCollection"))
344             {
345                 AssignIDtoCollection((TCollection*)obj);
346             }
347     }
348 }
349
350 //______________________________________________________________________________
351 void AliAODEvent::SetStdNames()
352 {
353   // introduce the standard naming
354
355   if(fAODObjects->GetEntries()==kAODListN){
356     for(int i = 0;i < fAODObjects->GetEntries();i++){
357       TObject *fObj = fAODObjects->At(i);
358       if(fObj->InheritsFrom("TNamed")){
359         ((TNamed*)fObj)->SetName(fAODListName[i]);
360       }
361       else if(fObj->InheritsFrom("TClonesArray")){
362         ((TClonesArray*)fObj)->SetName(fAODListName[i]);
363       }
364     }
365   }
366   else{
367     printf("%s:%d SetStdNames() Wrong number of Std Entries \n",(char*)__FILE__,__LINE__);
368   }
369
370
371 void AliAODEvent::CreateStdFolders()
372 {
373     // Create the standard folder structure
374   if(fAODFolder)delete fAODFolder;
375     fAODFolder = gROOT->GetRootFolder()->AddFolder("AOD", "AOD");
376     if(fAODObjects->GetEntries()==kAODListN){
377         for(int i = 0;i < fAODObjects->GetEntries();i++){
378             TObject *fObj = fAODObjects->At(i);
379             if(fObj->InheritsFrom("TClonesArray")){
380                 fAODFolder->AddFolder(fAODListName[i], fAODListName[i], (TCollection*) fObj);
381             } else {
382                 fAODFolder->AddFolder(fAODListName[i], fAODListName[i], 0);
383             }
384         }
385     }
386     else{
387         printf("%s:%d CreateStdFolders() Wrong number of Std Entries \n",(char*)__FILE__,__LINE__);
388     }
389
390
391 //______________________________________________________________________________
392 void AliAODEvent::GetStdContent()
393 {
394   // set pointers for standard content
395
396   fHeader        = (AliAODHeader*)fAODObjects->FindObject("header");
397   fTracks        = (TClonesArray*)fAODObjects->FindObject("tracks");
398   fVertices      = (TClonesArray*)fAODObjects->FindObject("vertices");
399   fV0s           = (TClonesArray*)fAODObjects->FindObject("v0s");
400   fCascades      = (TClonesArray*)fAODObjects->FindObject("cascades");
401   fTracklets     = (AliAODTracklets*)fAODObjects->FindObject("tracklets");
402   fJets          = (TClonesArray*)fAODObjects->FindObject("jets");
403   fEmcalCells    = (AliAODCaloCells*)fAODObjects->FindObject("emcalCells");
404   fPhosCells     = (AliAODCaloCells*)fAODObjects->FindObject("phosCells");
405   fCaloClusters  = (TClonesArray*)fAODObjects->FindObject("caloClusters");
406   fEMCALTrigger  = (AliAODCaloTrigger*)fAODObjects->FindObject("emcalTrigger");
407   fPHOSTrigger   = (AliAODCaloTrigger*)fAODObjects->FindObject("phosTrigger");
408   fFmdClusters   = (TClonesArray*)fAODObjects->FindObject("fmdClusters");
409   fPmdClusters   = (TClonesArray*)fAODObjects->FindObject("pmdClusters");
410   fHMPIDrings    = (TClonesArray*)fAODObjects->FindObject("hmpidRings");  
411   fDimuons       = (TClonesArray*)fAODObjects->FindObject("dimuons");
412   fAODTZERO      = (AliAODTZERO*)fAODObjects->FindObject("AliAODTZERO");
413   fAODVZERO      = (AliAODVZERO*)fAODObjects->FindObject("AliAODVZERO");
414   fAODZDC        = (AliAODZDC*)fAODObjects->FindObject("AliAODZDC");
415   fTOFHeader     = (AliTOFHeader*)fAODObjects->FindObject("AliTOFHeader");
416 #ifdef MFT_UPGRADE
417   fAODMFT        = (AliAODMFT*)fAODObjects->FindObject("AliAODMFT");
418 #endif
419 }
420
421 //______________________________________________________________________________
422 void AliAODEvent::ResetStd(Int_t trkArrSize, 
423                            Int_t vtxArrSize, 
424                            Int_t v0ArrSize,
425                            Int_t cascadeArrSize,
426                            Int_t jetSize, 
427                            Int_t caloClusSize, 
428                            Int_t fmdClusSize, 
429                            Int_t pmdClusSize,
430                            Int_t hmpidRingsSize,
431                            Int_t dimuonArrSize
432                            )
433 {
434   // deletes content of standard arrays and resets size 
435   if (fTracks) {
436     fTracks->Delete();
437     if (trkArrSize > fTracks->GetSize()) 
438       fTracks->Expand(trkArrSize);
439   }
440   if (fVertices) {
441     fVertices->Delete();
442     if (vtxArrSize > fVertices->GetSize()) 
443       fVertices->Expand(vtxArrSize);
444   }
445   if (fV0s) {
446     fV0s->Delete();
447     if (v0ArrSize > fV0s->GetSize()) 
448       fV0s->Expand(v0ArrSize);
449   }
450   if (fCascades) {
451     fCascades->Delete();
452     if (cascadeArrSize > fCascades->GetSize()) 
453       fCascades->Expand(cascadeArrSize);
454   }
455   if (fJets) {
456     fJets->Delete();
457     if (jetSize > fJets->GetSize())
458       fJets->Expand(jetSize);
459   }
460   if (fCaloClusters) {
461     fCaloClusters->Delete();
462     if (caloClusSize > fCaloClusters->GetSize()) 
463       fCaloClusters->Expand(caloClusSize);
464   }
465   if (fFmdClusters) {
466     fFmdClusters->Delete();
467     if (fmdClusSize > fFmdClusters->GetSize()) 
468       fFmdClusters->Expand(fmdClusSize);
469   }
470   if (fPmdClusters) {
471     fPmdClusters->Delete();
472     if (pmdClusSize > fPmdClusters->GetSize()) 
473       fPmdClusters->Expand(pmdClusSize);
474   }
475   if (fHMPIDrings) {
476      fHMPIDrings->Delete();
477     if (hmpidRingsSize > fHMPIDrings->GetSize()) 
478       fHMPIDrings->Expand(hmpidRingsSize);
479   }
480   if (fDimuons) {
481     fDimuons->Delete();
482     if (dimuonArrSize > fDimuons->GetSize()) 
483       fDimuons->Expand(dimuonArrSize);
484   }
485   if (fTracklets)
486     fTracklets->DeleteContainer();
487   if (fPhosCells)
488     fPhosCells->DeleteContainer();  
489   if (fEmcalCells)
490     fEmcalCells->DeleteContainer();
491   
492   if (fEMCALTrigger)
493         fEMCALTrigger->DeAllocate();
494   if (fPHOSTrigger)
495         fPHOSTrigger->DeAllocate();
496
497 }
498
499 void AliAODEvent::ClearStd()
500 {
501   // clears the standard arrays
502   if (fHeader)
503     fHeader        ->Clear();
504   if (fTracks)
505     fTracks        ->Delete();
506   if (fVertices)
507     fVertices      ->Delete();
508   if (fV0s)
509     fV0s           ->Delete();
510   if (fCascades)
511     fCascades      ->Delete();
512   if (fTracklets)
513     fTracklets     ->DeleteContainer();
514   if (fJets)
515     fJets          ->Delete();
516   if (fEmcalCells)
517     fEmcalCells    ->DeleteContainer();
518   if (fPhosCells)
519     fPhosCells     ->DeleteContainer();
520   if (fCaloClusters)
521     fCaloClusters  ->Delete();
522   if (fFmdClusters)
523     fFmdClusters   ->Clear();
524   if (fPmdClusters)
525     fPmdClusters   ->Clear();  
526   if (fHMPIDrings) 
527      fHMPIDrings   ->Clear();    
528   if (fDimuons)
529     fDimuons       ->Clear();
530         
531   if (fEMCALTrigger)
532         fEMCALTrigger->DeAllocate();
533   if (fPHOSTrigger)
534         fPHOSTrigger->DeAllocate();
535 }
536
537 //_________________________________________________________________
538 Int_t AliAODEvent::GetPHOSClusters(TRefArray *clusters) const
539 {
540   // fills the provided TRefArray with all found phos clusters
541   
542   clusters->Clear();
543   
544   AliAODCaloCluster *cl = 0;
545   Bool_t first = kTRUE;
546   for (Int_t i = 0; i < GetNumberOfCaloClusters() ; i++) {
547     if ( (cl = GetCaloCluster(i)) ) {
548       if (cl->IsPHOS()){
549         if(first) {
550           new (clusters) TRefArray(TProcessID::GetProcessWithUID(cl)); 
551           first=kFALSE;
552         }
553         clusters->Add(cl);
554         //printf("IsPHOS cluster %d, E %2.3f Size: %d \n",i,cl->E(),clusters->GetEntriesFast());
555       }
556     }
557   }
558   return clusters->GetEntriesFast();
559 }
560
561 //_________________________________________________________________
562 Int_t AliAODEvent::GetEMCALClusters(TRefArray *clusters) const
563 {
564   // fills the provided TRefArray with all found emcal clusters
565
566   clusters->Clear();
567   AliAODCaloCluster *cl = 0;
568   Bool_t first = kTRUE;
569   for (Int_t i = 0; i < GetNumberOfCaloClusters(); i++) {
570     if ( (cl = GetCaloCluster(i)) ) {
571       if (cl->IsEMCAL()){
572         if(first) {
573           new (clusters) TRefArray(TProcessID::GetProcessWithUID(cl)); 
574           first=kFALSE;
575         }
576         clusters->Add(cl);
577         //printf("IsEMCal cluster %d, E %2.3f Size: %d \n",i,cl->E(),clusters->GetEntriesFast());
578       }
579     }
580   }
581   return clusters->GetEntriesFast();
582 }
583
584
585 //______________________________________________________________________________
586 Int_t AliAODEvent::GetMuonTracks(TRefArray *muonTracks) const
587 {
588   // fills the provided TRefArray with all found muon tracks
589
590   muonTracks->Clear();
591
592   AliAODTrack *track = 0;
593   for (Int_t iTrack = 0; iTrack < GetNTracks(); iTrack++) {
594     track = GetTrack(iTrack);
595     if (track->IsMuonTrack()) {
596       muonTracks->Add(track);
597     }
598   }
599   
600   return muonTracks->GetEntriesFast();
601 }
602
603
604 //______________________________________________________________________________
605 Int_t AliAODEvent::GetNumberOfMuonTracks() const
606 {
607   // get number of muon tracks
608   Int_t nMuonTracks=0;
609   for (Int_t iTrack = 0; iTrack < GetNTracks(); iTrack++) {
610     if ((GetTrack(iTrack))->IsMuonTrack()) {
611        nMuonTracks++;
612     }
613   }
614   
615   return nMuonTracks;
616 }
617
618 //______________________________________________________________________________
619 void AliAODEvent::ReadFromTree(TTree *tree, Option_t* opt /*= ""*/)
620 {
621     // Connects aod event to tree
622   
623   if(!tree){
624     AliWarning("Zero Pointer to Tree \n");
625     return;
626   }
627     // load the TTree
628   if(!tree->GetTree())tree->LoadTree(0);
629   
630     // Try to find AliAODEvent
631   AliAODEvent *aodEvent = 0;
632   aodEvent = (AliAODEvent*)tree->GetTree()->GetUserInfo()->FindObject("AliAODEvent");
633   if(aodEvent){
634     // This event is connected to the tree by definition, just say so
635     aodEvent->SetConnected();
636       // Check if already connected to tree
637     TList* connectedList = (TList*) (tree->GetUserInfo()->FindObject("AODObjectsConnectedToTree"));
638     if (connectedList && (!strcmp(opt, "reconnect"))) {
639         // If connected use the connected list of objects
640         if (fAODObjects != connectedList) {
641            delete fAODObjects;
642            fAODObjects = connectedList;
643         }   
644         GetStdContent(); 
645         fConnected = kTRUE;
646         return;
647     } 
648       // Connect to tree
649       // prevent a memory leak when reading back the TList
650 //      if (!(strcmp(opt, "reconnect"))) fAODObjects->Delete();
651     
652       // create a new TList from the UserInfo TList... 
653       // copy constructor does not work...
654     //    fAODObjects = (TList*)(aodEvent->GetList()->Clone());
655     fAODObjects = (TList*)aodEvent->GetList();
656     fAODObjects->SetOwner(kTRUE);
657     if(fAODObjects->GetEntries()<kAODListN)
658     {
659       AliWarning(Form("AliAODEvent::ReadFromTree() TList contains less than the standard contents %d < %d"
660                       " That might be fine though (at least for filtered AODs)",fAODObjects->GetEntries(),kAODListN));
661     }
662       //
663       // Let's find out whether we have friends
664     TList* friendL = tree->GetTree()->GetListOfFriends();
665     if (friendL) 
666     {
667       TIter next(friendL);
668       TFriendElement* fe;
669       while ((fe = (TFriendElement*)next())){
670         aodEvent = (AliAODEvent*)(fe->GetTree()->GetUserInfo()->FindObject("AliAODEvent"));
671         if (!aodEvent) {
672           printf("No UserInfo on tree \n");
673         } else {
674           
675           //          TList* objL = (TList*)(aodEvent->GetList()->Clone());
676           TList* objL = (TList*)aodEvent->GetList();
677           printf("Get list of object from tree %d !!\n", objL->GetEntries());
678           TIter nextobject(objL);
679           TObject* obj =  0;
680           while((obj = nextobject()))
681           {
682             printf("Adding object from friend %s !\n", obj->GetName());
683             fAODObjects->Add(obj);
684           } // object "branch" loop
685         } // has userinfo  
686       } // friend loop
687     } // has friends    
688       // set the branch addresses
689     TIter next(fAODObjects);
690     TNamed *el;
691     while((el=(TNamed*)next())){
692       TString bname(el->GetName());
693         // check if branch exists under this Name
694       TBranch *br = tree->GetTree()->GetBranch(bname.Data());
695       if(br){
696         tree->SetBranchAddress(bname.Data(),fAODObjects->GetObjectRef(el));
697       } else {
698         br = tree->GetBranch(Form("%s.",bname.Data()));
699         if(br){
700           tree->SetBranchAddress(Form("%s.",bname.Data()),fAODObjects->GetObjectRef(el));
701         }
702         else{
703           printf("%s %d AliAODEvent::ReadFromTree() No Branch found with Name %s. \n",
704                  (char*)__FILE__,__LINE__,bname.Data());
705         }       
706       }
707     }
708     GetStdContent();
709       // when reading back we are not owner of the list 
710       // must not delete it
711     fAODObjects->SetOwner(kTRUE);
712     fAODObjects->SetName("AODObjectsConnectedToTree");
713       // we are not owner of the list objects 
714       // must not delete it
715     tree->GetUserInfo()->Add(fAODObjects);
716     fConnected = kTRUE;
717   }// no aodEvent
718   else {
719       // we can't get the list from the user data, create standard content
720       // and set it by hand
721     CreateStdContent();
722     TIter next(fAODObjects);
723     TNamed *el;
724     while((el=(TNamed*)next())){
725       TString bname(el->GetName());    
726       tree->SetBranchAddress(bname.Data(),fAODObjects->GetObjectRef(el));
727     }
728     GetStdContent();
729       // when reading back we are not owner of the list 
730       // must not delete it
731     fAODObjects->SetOwner(kTRUE);
732   }
733 }
734   //______________________________________________________________________________
735 Int_t  AliAODEvent::GetNumberOfPileupVerticesSPD() const{
736   // count number of SPD pileup vertices
737   Int_t nVertices=GetNumberOfVertices();
738   Int_t nPileupVertices=0;
739   for(Int_t iVert=0; iVert<nVertices; iVert++){
740     AliAODVertex *v=GetVertex(iVert);
741     if(v->GetType()==AliAODVertex::kPileupSPD) nPileupVertices++;
742   }
743   return nPileupVertices;
744 }
745 //______________________________________________________________________________
746 Int_t  AliAODEvent::GetNumberOfPileupVerticesTracks() const{
747   // count number of track pileup vertices
748   Int_t nVertices=GetNumberOfVertices();
749   Int_t nPileupVertices=0;
750   for(Int_t iVert=0; iVert<nVertices; iVert++){
751     AliAODVertex *v=GetVertex(iVert);
752     if(v->GetType()==AliAODVertex::kPileupTracks) nPileupVertices++;
753   }
754   return nPileupVertices;
755 }
756 //______________________________________________________________________________
757 AliAODVertex* AliAODEvent::GetPrimaryVertexSPD() const{
758   // Get SPD primary vertex
759   Int_t nVertices=GetNumberOfVertices();
760   for(Int_t iVert=0; iVert<nVertices; iVert++){
761     AliAODVertex *v=GetVertex(iVert);
762     if(v->GetType()==AliAODVertex::kMainSPD) return v;
763   }
764   return 0;
765 }
766 //______________________________________________________________________________
767 AliAODVertex* AliAODEvent::GetPileupVertexSPD(Int_t iV) const{
768   // Get pile-up vertex iV
769   Int_t nVertices=GetNumberOfVertices();
770   Int_t counter=0;
771   for(Int_t iVert=0; iVert<nVertices; iVert++){
772     AliAODVertex *v=GetVertex(iVert);
773     if(v->GetType()==AliAODVertex::kPileupSPD){
774       if(counter==iV) return v;
775       ++counter;
776     }
777   }
778   return 0;
779 }
780 //______________________________________________________________________________
781 AliAODVertex* AliAODEvent::GetPileupVertexTracks(Int_t iV) const{
782   // Get pile-up vertex iV
783   Int_t nVertices=GetNumberOfVertices();
784   Int_t counter=0;
785   for(Int_t iVert=0; iVert<nVertices; iVert++){
786     AliAODVertex *v=GetVertex(iVert);
787     if(v->GetType()==AliAODVertex::kPileupTracks){
788       if(counter==iV) return v;
789       ++counter;
790     }
791   }
792   return 0;
793 }
794 //______________________________________________________________________________
795 Bool_t  AliAODEvent::IsPileupFromSPD(Int_t minContributors, 
796                                      Double_t minZdist, 
797                                      Double_t nSigmaZdist, 
798                                      Double_t nSigmaDiamXY, 
799                                      Double_t nSigmaDiamZ) const{
800   //
801   // This function checks if there was a pile up
802   // reconstructed with SPD
803   //
804   AliAODVertex *mainV=GetPrimaryVertexSPD();
805   if(!mainV) return kFALSE;
806   Int_t nc1=mainV->GetNContributors();
807   if(nc1<1) return kFALSE;
808   Int_t nPileVert=GetNumberOfPileupVerticesSPD();
809   if(nPileVert==0) return kFALSE;
810   Int_t nVertices=GetNumberOfVertices();
811   
812   for(Int_t iVert=0; iVert<nVertices; iVert++){
813     AliAODVertex *pv=GetVertex(iVert);
814     if(pv->GetType()!=AliAODVertex::kPileupSPD) continue;
815     Int_t nc2=pv->GetNContributors();
816     if(nc2>=minContributors){
817       Double_t z1=mainV->GetZ();
818       Double_t z2=pv->GetZ();
819       Double_t distZ=TMath::Abs(z2-z1);
820       Double_t distZdiam=TMath::Abs(z2-GetDiamondZ());
821       Double_t cutZdiam=nSigmaDiamZ*TMath::Sqrt(GetSigma2DiamondZ());
822       if(GetSigma2DiamondZ()<0.0001)cutZdiam=99999.; //protection for missing z diamond information
823       if(distZ>minZdist && distZdiam<cutZdiam){
824         Double_t x2=pv->GetX();
825         Double_t y2=pv->GetY();
826         Double_t distXdiam=TMath::Abs(x2-GetDiamondX());
827         Double_t distYdiam=TMath::Abs(y2-GetDiamondY());
828         Double_t cov1[6],cov2[6];       
829         mainV->GetCovarianceMatrix(cov1);
830         pv->GetCovarianceMatrix(cov2);
831         Double_t errxDist=TMath::Sqrt(cov2[0]+GetSigma2DiamondX());
832         Double_t erryDist=TMath::Sqrt(cov2[2]+GetSigma2DiamondY());
833         Double_t errzDist=TMath::Sqrt(cov1[5]+cov2[5]);
834         Double_t cutXdiam=nSigmaDiamXY*errxDist;
835         if(GetSigma2DiamondX()<0.0001)cutXdiam=99999.; //protection for missing diamond information
836         Double_t cutYdiam=nSigmaDiamXY*erryDist;
837         if(GetSigma2DiamondY()<0.0001)cutYdiam=99999.; //protection for missing diamond information
838         if( (distXdiam<cutXdiam) && (distYdiam<cutYdiam) && (distZ>nSigmaZdist*errzDist) ){
839           return kTRUE;
840         }
841       }
842     }
843   }
844   return kFALSE;
845 }
846
847 //______________________________________________________________________________
848 void AliAODEvent::Print(Option_t *) const
849 {
850   // Print the names of the all branches
851   TIter next(fAODObjects);
852   TNamed *el;
853   Printf(">>>>>  AOD  Content <<<<<");    
854   while((el=(TNamed*)next())){
855     Printf(">> %s ",el->GetName());      
856   }
857   Printf(">>>>>                <<<<<");    
858   
859   return;
860 }
861
862 void AliAODEvent::AssignIDtoCollection(const TCollection* col)
863 {
864     // Static method which assigns a ID to each object in a collection
865     // In this way the objects are marked as referenced and written with 
866     // an ID. This has the advantage that TRefs to this objects can be 
867     // written by a subsequent process.
868     TIter next(col);
869     TObject* obj;
870     while ((obj = next()))
871         TProcessID::AssignID(obj);
872 }
873
874 Bool_t AliAODEvent::IsPileupFromSPDInMultBins() const {
875     Int_t nTracklets=GetTracklets()->GetNumberOfTracklets();
876     if(nTracklets<20) return IsPileupFromSPD(3,0.8);
877     else if(nTracklets<50) return IsPileupFromSPD(4,0.8);
878     else return IsPileupFromSPD(5,0.8);
879 }
880
881 void AliAODEvent::Reset()
882 {
883   // Handle the cases
884   // Std content + Non std content
885
886   ClearStd();
887
888   if(fAODObjects->GetSize()>kAODListN){
889     // we have non std content
890     // this also covers aodfriends
891     for(int i = kAODListN;i < fAODObjects->GetSize();++i){
892       TObject *pObject = fAODObjects->At(i);
893       // TClonesArrays
894       if(pObject->InheritsFrom(TClonesArray::Class())){
895        ((TClonesArray*)pObject)->Delete();
896       }
897       else if(!pObject->InheritsFrom(TCollection::Class())){
898        TClass *pClass = TClass::GetClass(pObject->ClassName());
899        if (pClass && pClass->GetListOfMethods()->FindObject("Clear")) {
900          AliDebug(1, Form("Clear for object %s class %s", pObject->GetName(), pObject->ClassName()));
901          pObject->Clear();
902        }
903        else {
904          AliDebug(1, Form("ResetWithPlacementNew for object %s class %s", pObject->GetName(), pObject->ClassName()));
905           Long_t dtoronly = TObject::GetDtorOnly();
906           TObject::SetDtorOnly(pObject);
907           delete pObject;
908           pClass->New(pObject);
909           TObject::SetDtorOnly((void*)dtoronly);
910        }
911       }
912       else{
913        AliWarning(Form("No reset for %s \n",
914                        pObject->ClassName()));
915       }
916     }
917   }
918 }
919
920 Float_t AliAODEvent::GetVZEROEqMultiplicity(Int_t i) const
921 {
922   // Get VZERO Multiplicity for channel i
923   // Themethod uses the equalization factors
924   // stored in the ESD-run object in order to
925   // get equal multiplicities within a VZERO rins (1/8 of VZERO)
926   if (!fAODVZERO || !fHeader) return -1;
927
928   Int_t ring = i/8;
929   Float_t factorSum = 0;
930   for(Int_t j = 8*ring; j < (8*ring+8); ++j) {
931     factorSum += fHeader->GetVZEROEqFactors(j);
932   }
933   Float_t factor = fHeader->GetVZEROEqFactors(i)*8./factorSum;
934
935   return (fAODVZERO->GetMultiplicity(i)/factor);
936 }
937
938 //------------------------------------------------------------
939 void  AliAODEvent::SetTOFHeader(const AliTOFHeader *header)
940 {
941   //
942   // Set the TOF event_time
943   //
944
945   if (fTOFHeader) {
946     *fTOFHeader=*header;
947     //fTOFHeader->SetName(fgkESDListName[kTOFHeader]);
948   }
949   else {
950     // for analysis of reconstructed events
951     // when this information is not avaliable
952     fTOFHeader = new AliTOFHeader(*header);
953     //AddObject(fTOFHeader);
954   }
955
956 }
957 //------------------------------------------------------------
958 AliAODHMPIDrings *AliAODEvent::GetHMPIDringForTrackID(Int_t trackID)
959 {
960   //
961   // Returns the HMPID object if any for a given track ID
962   //
963   if(GetHMPIDrings())
964   {
965     for(Int_t ien = 0 ; ien < GetNHMPIDrings(); ien++)
966     {
967       if( ien == trackID ) return GetHMPIDring(ien);      
968     }//rings loop  
969   }
970   return 0;
971 }
972 //------------------------------------------------------------
973 Int_t AliAODEvent::GetNHMPIDrings()   
974
975   //
976   // If there is a list of HMPID rings in the given AOD event, return their number
977   //
978   if ( fHMPIDrings) return fHMPIDrings->GetEntriesFast(); 
979   else return -1;
980
981 //------------------------------------------------------------
982 AliAODHMPIDrings *AliAODEvent::GetHMPIDring(Int_t nRings)   
983
984   //
985   // If there is a list of HMPID rings in the given AOD event, return corresponding ring
986   //
987   if(fHMPIDrings) {
988     if(   (AliAODHMPIDrings*)fHMPIDrings->UncheckedAt(nRings) ) {
989       return (AliAODHMPIDrings*)fHMPIDrings->UncheckedAt(nRings);
990     }
991     else return 0x0;
992   }
993   else return 0x0;  
994 }
995 //------------------------------------------------------------