]> git.uio.no Git - u/mrichter/AliRoot.git/blame_incremental - STEER/AOD/AliAODEvent.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Moving the classes that belong to the following libraries: STEERBase, ESD, CDB, AOD...
[u/mrichter/AliRoot.git] / STEER / AOD / AliAODEvent.cxx
... / ...
CommitLineData
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
35ClassImp(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 "fmdClusters",
49 "pmdClusters",
50 "dimuons",
51 "AliAODVZERO",
52 "AliAODZDC"
53
54};
55//______________________________________________________________________________
56AliAODEvent::AliAODEvent() :
57 AliVEvent(),
58 fAODObjects(new TList()),
59 fAODFolder(0),
60 fConnected(kFALSE),
61 fHeader(0),
62 fTracks(0),
63 fVertices(0),
64 fV0s(0),
65 fCascades(0),
66 fTracklets(0),
67 fJets(0),
68 fEmcalCells(0),
69 fPhosCells(0),
70 fCaloClusters(0),
71 fFmdClusters(0),
72 fPmdClusters(0),
73 fDimuons(0),
74 fAODVZERO(0),
75 fAODZDC(0)
76{
77 // default constructor
78}
79
80//______________________________________________________________________________
81AliAODEvent::AliAODEvent(const AliAODEvent& aod):
82 AliVEvent(aod),
83 fAODObjects(new TList()),
84 fAODFolder(0),
85 fConnected(kFALSE),
86 fHeader(new AliAODHeader(*aod.fHeader)),
87 fTracks(new TClonesArray(*aod.fTracks)),
88 fVertices(new TClonesArray(*aod.fVertices)),
89 fV0s(new TClonesArray(*aod.fV0s)),
90 fCascades(new TClonesArray(*aod.fCascades)),
91 fTracklets(new AliAODTracklets(*aod.fTracklets)),
92 fJets(new TClonesArray(*aod.fJets)),
93 fEmcalCells(new AliAODCaloCells(*aod.fEmcalCells)),
94 fPhosCells(new AliAODCaloCells(*aod.fPhosCells)),
95 fCaloClusters(new TClonesArray(*aod.fCaloClusters)),
96 fFmdClusters(new TClonesArray(*aod.fFmdClusters)),
97 fPmdClusters(new TClonesArray(*aod.fPmdClusters)),
98 fDimuons(new TClonesArray(*aod.fDimuons)),
99 fAODVZERO(new AliAODVZERO(*aod.fAODVZERO)),
100 fAODZDC(new AliAODZDC(*aod.fAODZDC))
101{
102 // Copy constructor
103 AddObject(fHeader);
104 AddObject(fTracks);
105 AddObject(fVertices);
106 AddObject(fV0s);
107 AddObject(fCascades);
108 AddObject(fTracklets);
109 AddObject(fJets);
110 AddObject(fEmcalCells);
111 AddObject(fPhosCells);
112 AddObject(fCaloClusters);
113 AddObject(fFmdClusters);
114 AddObject(fPmdClusters);
115 AddObject(fDimuons);
116 AddObject(fAODVZERO);
117 AddObject(fAODZDC);
118 fConnected = aod.fConnected;
119 GetStdContent();
120 CreateStdFolders();
121}
122
123//______________________________________________________________________________
124AliAODEvent & AliAODEvent::operator=(const AliAODEvent& aod) {
125
126 // Assignment operator
127
128 if(&aod == this) return *this;
129 AliVEvent::operator=(aod);
130
131 // This assumes that the list is already created
132 // and that the virtual void Copy(Tobject&) function
133 // is correctly implemented in the derived class
134 // otherwise only TObject::Copy() will be used
135
136 if((fAODObjects->GetSize()==0)&&(aod.fAODObjects->GetSize()>=kAODListN)){
137 // We cover the case that we do not yet have the
138 // standard content but the source has it
139 CreateStdContent();
140 }
141
142 // Here we have the standard content without user additions, but the content is
143 // not matching the aod source.
144
145 // Iterate the list of source objects
146 TIter next(aod.GetList());
147 TObject *its = 0;
148 TString name;
149 while ((its = next())) {
150 name = its->GetName();
151 // Check if we have this object type in out list
152 TObject *mine = fAODObjects->FindObject(name);
153 if(!mine) {
154 // We have to create the same type of object.
155 TClass* pClass=TClass::GetClass(its->ClassName());
156 if (!pClass) {
157 AliWarning(Form("Can not find class description for entry %s (%s)\n",
158 its->ClassName(), name.Data()));
159 continue;
160 }
161 mine=(TObject*)pClass->New();
162 if(!mine){
163 // not in this: can be added to list
164 AliWarning(Form("%s:%d Could not find %s for copying \n",
165 (char*)__FILE__,__LINE__,name.Data()));
166 continue;
167 }
168 if(mine->InheritsFrom("TNamed")) {
169 ((TNamed*)mine)->SetName(name);
170 } else if(mine->InheritsFrom("TCollection")){
171 if(mine->InheritsFrom("TClonesArray")) {
172 TClonesArray *itscl = dynamic_cast<TClonesArray*>(its);
173 if (!itscl) {
174 AliWarning(Form("Class description for entry %s (%s) not TClonesArray\n",
175 its->ClassName(), name.Data()));
176 continue;
177
178 }
179 dynamic_cast<TClonesArray*>(mine)->SetClass(itscl->GetClass(), itscl->GetSize());
180 }
181 dynamic_cast<TCollection*>(mine)->SetName(name);
182 }
183 AliDebug(1, Form("adding object %s of type %s", mine->GetName(), mine->ClassName()));
184 AddObject(mine);
185 }
186 // Now we have an object of the same type and name, but different content.
187 if(!its->InheritsFrom("TCollection")){
188 // simple objects (do they have a Copy method that calls operator= ?)
189 its->Copy(*mine);
190 } else if (its->InheritsFrom("TClonesArray")) {
191 // Create or expand the tclonesarray pointers
192 // so we can directly copy to the object
193 TClonesArray *its_tca = (TClonesArray*)its;
194 TClonesArray *mine_tca = (TClonesArray*)mine;
195 // this leaves the capacity of the TClonesArray the same
196 // except for a factor of 2 increase when size > capacity
197 // does not release any memory occupied by the tca
198 Int_t its_entries = its_tca->GetEntriesFast();
199 mine_tca->ExpandCreate(its_entries);
200 for(int i=0; i<its_entries; i++){
201 // copy
202 TObject *mine_tca_obj = mine_tca->At(i);
203 TObject *its_tca_obj = its_tca->At(i);
204 // no need to delete first
205 // pointers within the class should be handled by Copy()...
206 // Can there be Empty slots?
207 its_tca_obj->Copy(*mine_tca_obj);
208 }
209 } else {
210 AliWarning(Form("%s:%d cannot copy TCollection \n",
211 (char*)__FILE__,__LINE__));
212 }
213 }
214 fConnected = aod.fConnected;
215 return *this;
216}
217
218
219//______________________________________________________________________________
220AliAODEvent::~AliAODEvent()
221{
222// destructor
223 if(!fConnected) delete fAODObjects;
224 delete fAODFolder;
225}
226
227//______________________________________________________________________________
228void AliAODEvent::AddObject(TObject* obj)
229{
230 // Add an object to the list of objects.
231 // Please be aware that in order to increase performance you should
232 // refrain from using TObjArrays (if possible). Use TClonesArrays, instead.
233
234 if ( !fAODObjects->FindObject(obj) )
235 {
236 fAODObjects->AddLast(obj);
237 }
238}
239
240//______________________________________________________________________________
241void AliAODEvent::RemoveObject(TObject* obj)
242{
243 // Removes an object from the list of objects.
244
245 fAODObjects->Remove(obj);
246}
247
248//______________________________________________________________________________
249TObject *AliAODEvent::FindListObject(const char *objName) const
250{
251 // Return the pointer to the object with the given name.
252
253 return fAODObjects->FindObject(objName);
254}
255
256//______________________________________________________________________________
257void AliAODEvent::CreateStdContent()
258{
259 // create the standard AOD content and set pointers
260
261 // create standard objects and add them to the TList of objects
262 AddObject(new AliAODHeader());
263 AddObject(new TClonesArray("AliAODTrack", 0));
264 AddObject(new TClonesArray("AliAODVertex", 0));
265 AddObject(new TClonesArray("AliAODv0", 0));
266 AddObject(new TClonesArray("AliAODcascade", 0));
267 AddObject(new AliAODTracklets());
268 AddObject(new TClonesArray("AliAODJet", 0));
269 AddObject(new AliAODCaloCells());
270 AddObject(new AliAODCaloCells());
271 AddObject(new TClonesArray("AliAODCaloCluster", 0));
272 AddObject(new TClonesArray("AliAODFmdCluster", 0));
273 AddObject(new TClonesArray("AliAODPmdCluster", 0));
274 AddObject(new TClonesArray("AliAODDimuon", 0));
275 AddObject(new AliAODVZERO());
276 AddObject(new AliAODZDC());
277 // set names
278 SetStdNames();
279
280 // read back pointers
281 GetStdContent();
282 CreateStdFolders();
283 return;
284}
285
286void AliAODEvent::MakeEntriesReferencable()
287{
288 // Make all entries referencable in a subsequent process
289 //
290 TIter next(fAODObjects);
291 TObject* obj;
292 while ((obj = next()))
293 {
294 if(obj->InheritsFrom("TCollection"))
295 {
296 AssignIDtoCollection((TCollection*)obj);
297 }
298 }
299}
300
301//______________________________________________________________________________
302void AliAODEvent::SetStdNames()
303{
304 // introduce the standard naming
305
306 if(fAODObjects->GetEntries()==kAODListN){
307 for(int i = 0;i < fAODObjects->GetEntries();i++){
308 TObject *fObj = fAODObjects->At(i);
309 if(fObj->InheritsFrom("TNamed")){
310 ((TNamed*)fObj)->SetName(fAODListName[i]);
311 }
312 else if(fObj->InheritsFrom("TClonesArray")){
313 ((TClonesArray*)fObj)->SetName(fAODListName[i]);
314 }
315 }
316 }
317 else{
318 printf("%s:%d SetStdNames() Wrong number of Std Entries \n",(char*)__FILE__,__LINE__);
319 }
320}
321
322void AliAODEvent::CreateStdFolders()
323{
324 // Create the standard folder structure
325 if(fAODFolder)delete fAODFolder;
326 fAODFolder = gROOT->GetRootFolder()->AddFolder("AOD", "AOD");
327 if(fAODObjects->GetEntries()==kAODListN){
328 for(int i = 0;i < fAODObjects->GetEntries();i++){
329 TObject *fObj = fAODObjects->At(i);
330 if(fObj->InheritsFrom("TClonesArray")){
331 fAODFolder->AddFolder(fAODListName[i], fAODListName[i], (TCollection*) fObj);
332 } else {
333 fAODFolder->AddFolder(fAODListName[i], fAODListName[i], 0);
334 }
335 }
336 }
337 else{
338 printf("%s:%d CreateStdFolders() Wrong number of Std Entries \n",(char*)__FILE__,__LINE__);
339 }
340}
341
342//______________________________________________________________________________
343void AliAODEvent::GetStdContent()
344{
345 // set pointers for standard content
346
347 fHeader = (AliAODHeader*)fAODObjects->FindObject("header");
348 fTracks = (TClonesArray*)fAODObjects->FindObject("tracks");
349 fVertices = (TClonesArray*)fAODObjects->FindObject("vertices");
350 fV0s = (TClonesArray*)fAODObjects->FindObject("v0s");
351 fCascades = (TClonesArray*)fAODObjects->FindObject("cascades");
352 fTracklets = (AliAODTracklets*)fAODObjects->FindObject("tracklets");
353 fJets = (TClonesArray*)fAODObjects->FindObject("jets");
354 fEmcalCells = (AliAODCaloCells*)fAODObjects->FindObject("emcalCells");
355 fPhosCells = (AliAODCaloCells*)fAODObjects->FindObject("phosCells");
356 fCaloClusters = (TClonesArray*)fAODObjects->FindObject("caloClusters");
357 fFmdClusters = (TClonesArray*)fAODObjects->FindObject("fmdClusters");
358 fPmdClusters = (TClonesArray*)fAODObjects->FindObject("pmdClusters");
359 fDimuons = (TClonesArray*)fAODObjects->FindObject("dimuons");
360 fAODVZERO = (AliAODVZERO*)fAODObjects->FindObject("AliAODVZERO");
361 fAODZDC = (AliAODZDC*)fAODObjects->FindObject("AliAODZDC");
362}
363
364//______________________________________________________________________________
365void AliAODEvent::ResetStd(Int_t trkArrSize,
366 Int_t vtxArrSize,
367 Int_t v0ArrSize,
368 Int_t cascadeArrSize,
369 Int_t jetSize,
370 Int_t caloClusSize,
371 Int_t fmdClusSize,
372 Int_t pmdClusSize,
373 Int_t dimuonArrSize
374 )
375{
376 // deletes content of standard arrays and resets size
377
378 if (fTracks) {
379 fTracks->Delete();
380 if (trkArrSize > fTracks->GetSize())
381 fTracks->Expand(trkArrSize);
382 }
383 if (fVertices) {
384 fVertices->Delete();
385 if (vtxArrSize > fVertices->GetSize())
386 fVertices->Expand(vtxArrSize);
387 }
388 if (fV0s) {
389 fV0s->Delete();
390 if (v0ArrSize > fV0s->GetSize())
391 fV0s->Expand(v0ArrSize);
392 }
393 if (fCascades) {
394 fCascades->Delete();
395 if (cascadeArrSize > fCascades->GetSize())
396 fCascades->Expand(cascadeArrSize);
397 }
398 if (fJets) {
399 fJets->Delete();
400 if (jetSize > fJets->GetSize())
401 fJets->Expand(jetSize);
402 }
403 if (fCaloClusters) {
404 fCaloClusters->Delete();
405 if (caloClusSize > fCaloClusters->GetSize())
406 fCaloClusters->Expand(caloClusSize);
407 }
408 if (fFmdClusters) {
409 fFmdClusters->Delete();
410 if (fmdClusSize > fFmdClusters->GetSize())
411 fFmdClusters->Expand(fmdClusSize);
412 }
413 if (fPmdClusters) {
414 fPmdClusters->Delete();
415 if (pmdClusSize > fPmdClusters->GetSize())
416 fPmdClusters->Expand(pmdClusSize);
417 }
418 if (fDimuons) {
419 fDimuons->Delete();
420 if (dimuonArrSize > fDimuons->GetSize())
421 fDimuons->Expand(dimuonArrSize);
422 }
423 if (fTracklets)
424 fTracklets->DeleteContainer();
425 if (fPhosCells)
426 fPhosCells->DeleteContainer();
427 if (fEmcalCells)
428 fEmcalCells->DeleteContainer();
429}
430
431void AliAODEvent::ClearStd()
432{
433 // clears the standard arrays
434 if (fHeader)
435 fHeader ->Clear();
436 if (fTracks)
437 fTracks ->Delete();
438 if (fVertices)
439 fVertices ->Delete();
440 if (fV0s)
441 fV0s ->Delete();
442 if (fCascades)
443 fCascades ->Delete();
444 if (fTracklets)
445 fTracklets ->DeleteContainer();
446 if (fJets)
447 fJets ->Delete();
448 if (fEmcalCells)
449 fEmcalCells ->DeleteContainer();
450 if (fPhosCells)
451 fPhosCells ->DeleteContainer();
452 if (fCaloClusters)
453 fCaloClusters ->Delete();
454 if (fFmdClusters)
455 fFmdClusters ->Clear();
456 if (fPmdClusters)
457 fPmdClusters ->Clear();
458 if (fDimuons)
459 fDimuons ->Clear();
460}
461
462//_________________________________________________________________
463Int_t AliAODEvent::GetPHOSClusters(TRefArray *clusters) const
464{
465 // fills the provided TRefArray with all found phos clusters
466
467 clusters->Clear();
468
469 AliAODCaloCluster *cl = 0;
470 Bool_t first = kTRUE;
471 for (Int_t i = 0; i < GetNumberOfCaloClusters() ; i++) {
472 if ( (cl = GetCaloCluster(i)) ) {
473 if (cl->IsPHOS()){
474 if(first) {
475 new (clusters) TRefArray(TProcessID::GetProcessWithUID(cl));
476 first=kFALSE;
477 }
478 clusters->Add(cl);
479 //printf("IsPHOS cluster %d, E %2.3f Size: %d \n",i,cl->E(),clusters->GetEntriesFast());
480 }
481 }
482 }
483 return clusters->GetEntriesFast();
484}
485
486//_________________________________________________________________
487Int_t AliAODEvent::GetEMCALClusters(TRefArray *clusters) const
488{
489 // fills the provided TRefArray with all found emcal clusters
490
491 clusters->Clear();
492 AliAODCaloCluster *cl = 0;
493 Bool_t first = kTRUE;
494 for (Int_t i = 0; i < GetNumberOfCaloClusters(); i++) {
495 if ( (cl = GetCaloCluster(i)) ) {
496 if (cl->IsEMCAL()){
497 if(first) {
498 new (clusters) TRefArray(TProcessID::GetProcessWithUID(cl));
499 first=kFALSE;
500 }
501 clusters->Add(cl);
502 //printf("IsEMCal cluster %d, E %2.3f Size: %d \n",i,cl->E(),clusters->GetEntriesFast());
503 }
504 }
505 }
506 return clusters->GetEntriesFast();
507}
508
509
510//______________________________________________________________________________
511Int_t AliAODEvent::GetMuonTracks(TRefArray *muonTracks) const
512{
513 // fills the provided TRefArray with all found muon tracks
514
515 muonTracks->Clear();
516
517 AliAODTrack *track = 0;
518 for (Int_t iTrack = 0; iTrack < GetNTracks(); iTrack++) {
519 track = GetTrack(iTrack);
520 if (track->IsMuonTrack()) {
521 muonTracks->Add(track);
522 }
523 }
524
525 return muonTracks->GetEntriesFast();
526}
527
528
529//______________________________________________________________________________
530Int_t AliAODEvent::GetNumberOfMuonTracks() const
531{
532 // get number of muon tracks
533 Int_t nMuonTracks=0;
534 for (Int_t iTrack = 0; iTrack < GetNTracks(); iTrack++) {
535 if ((GetTrack(iTrack))->IsMuonTrack()) {
536 nMuonTracks++;
537 }
538 }
539
540 return nMuonTracks;
541}
542
543//______________________________________________________________________________
544void AliAODEvent::ReadFromTree(TTree *tree, Option_t* opt /*= ""*/)
545{
546 // Connects aod event to tree
547
548 if(!tree){
549 AliWarning("Zero Pointer to Tree \n");
550 return;
551 }
552 // load the TTree
553 if(!tree->GetTree())tree->LoadTree(0);
554
555 // Try to find AliAODEvent
556 AliAODEvent *aodEvent = 0;
557 aodEvent = (AliAODEvent*)tree->GetTree()->GetUserInfo()->FindObject("AliAODEvent");
558 if(aodEvent){
559 // This event is connected to the tree by definition, just say so
560 aodEvent->SetConnected();
561 // Check if already connected to tree
562 TList* connectedList = (TList*) (tree->GetUserInfo()->FindObject("AODObjectsConnectedToTree"));
563 if (connectedList && (strcmp(opt, "reconnect"))) {
564 // If connected use the connected list of objects
565 delete fAODObjects;
566 fAODObjects = connectedList;
567 GetStdContent();
568 fConnected = kTRUE;
569 return;
570 }
571 // Connect to tree
572 // prevent a memory leak when reading back the TList
573// if (!(strcmp(opt, "reconnect"))) fAODObjects->Delete();
574
575 // create a new TList from the UserInfo TList...
576 // copy constructor does not work...
577 // fAODObjects = (TList*)(aodEvent->GetList()->Clone());
578 fAODObjects = (TList*)aodEvent->GetList();
579 fAODObjects->SetOwner(kTRUE);
580 if(fAODObjects->GetEntries()<kAODListN)
581 {
582 AliWarning(Form("AliAODEvent::ReadFromTree() TList contains less than the standard contents %d < %d"
583 " That might be fine though (at least for filtered AODs)",fAODObjects->GetEntries(),kAODListN));
584 }
585 //
586 // Let's find out whether we have friends
587 TList* friendL = tree->GetTree()->GetListOfFriends();
588 if (friendL)
589 {
590 TIter next(friendL);
591 TFriendElement* fe;
592 while ((fe = (TFriendElement*)next())){
593 aodEvent = (AliAODEvent*)(fe->GetTree()->GetUserInfo()->FindObject("AliAODEvent"));
594 if (!aodEvent) {
595 printf("No UserInfo on tree \n");
596 } else {
597
598 // TList* objL = (TList*)(aodEvent->GetList()->Clone());
599 TList* objL = (TList*)aodEvent->GetList();
600 printf("Get list of object from tree %d !!\n", objL->GetEntries());
601 TIter nextobject(objL);
602 TObject* obj = 0;
603 while((obj = nextobject()))
604 {
605 printf("Adding object from friend %s !\n", obj->GetName());
606 fAODObjects->Add(obj);
607 } // object "branch" loop
608 } // has userinfo
609 } // friend loop
610 } // has friends
611 // set the branch addresses
612 TIter next(fAODObjects);
613 TNamed *el;
614 while((el=(TNamed*)next())){
615 TString bname(el->GetName());
616 // check if branch exists under this Name
617 TBranch *br = tree->GetTree()->GetBranch(bname.Data());
618 if(br){
619 tree->SetBranchAddress(bname.Data(),fAODObjects->GetObjectRef(el));
620 } else {
621 br = tree->GetBranch(Form("%s.",bname.Data()));
622 if(br){
623 tree->SetBranchAddress(Form("%s.",bname.Data()),fAODObjects->GetObjectRef(el));
624 }
625 else{
626 printf("%s %d AliAODEvent::ReadFromTree() No Branch found with Name %s. \n",
627 (char*)__FILE__,__LINE__,bname.Data());
628 }
629 }
630 }
631 GetStdContent();
632 // when reading back we are not owner of the list
633 // must not delete it
634 fAODObjects->SetOwner(kTRUE);
635 fAODObjects->SetName("AODObjectsConnectedToTree");
636 // we are not owner of the list objects
637 // must not delete it
638 tree->GetUserInfo()->Add(fAODObjects);
639 fConnected = kTRUE;
640 }// no aodEvent
641 else {
642 // we can't get the list from the user data, create standard content
643 // and set it by hand
644 CreateStdContent();
645 TIter next(fAODObjects);
646 TNamed *el;
647 while((el=(TNamed*)next())){
648 TString bname(el->GetName());
649 tree->SetBranchAddress(bname.Data(),fAODObjects->GetObjectRef(el));
650 }
651 GetStdContent();
652 // when reading back we are not owner of the list
653 // must not delete it
654 fAODObjects->SetOwner(kTRUE);
655 }
656}
657 //______________________________________________________________________________
658Int_t AliAODEvent::GetNumberOfPileupVerticesSPD() const{
659 // count number of SPD pileup vertices
660 Int_t nVertices=GetNumberOfVertices();
661 Int_t nPileupVertices=0;
662 for(Int_t iVert=0; iVert<nVertices; iVert++){
663 AliAODVertex *v=GetVertex(iVert);
664 if(v->GetType()==AliAODVertex::kPileupSPD) nPileupVertices++;
665 }
666 return nPileupVertices;
667}
668//______________________________________________________________________________
669Int_t AliAODEvent::GetNumberOfPileupVerticesTracks() const{
670 // count number of track pileup vertices
671 Int_t nVertices=GetNumberOfVertices();
672 Int_t nPileupVertices=0;
673 for(Int_t iVert=0; iVert<nVertices; iVert++){
674 AliAODVertex *v=GetVertex(iVert);
675 if(v->GetType()==AliAODVertex::kPileupTracks) nPileupVertices++;
676 }
677 return nPileupVertices;
678}
679//______________________________________________________________________________
680AliAODVertex* AliAODEvent::GetPrimaryVertexSPD() const{
681 // Get SPD primary vertex
682 Int_t nVertices=GetNumberOfVertices();
683 for(Int_t iVert=0; iVert<nVertices; iVert++){
684 AliAODVertex *v=GetVertex(iVert);
685 if(v->GetType()==AliAODVertex::kMainSPD) return v;
686 }
687 return 0;
688}
689//______________________________________________________________________________
690AliAODVertex* AliAODEvent::GetPileupVertexSPD(Int_t iV) const{
691 // Get pile-up vertex iV
692 Int_t nVertices=GetNumberOfVertices();
693 Int_t counter=0;
694 for(Int_t iVert=0; iVert<nVertices; iVert++){
695 AliAODVertex *v=GetVertex(iVert);
696 if(v->GetType()==AliAODVertex::kPileupSPD){
697 if(counter==iV) return v;
698 ++counter;
699 }
700 }
701 return 0;
702}
703//______________________________________________________________________________
704AliAODVertex* AliAODEvent::GetPileupVertexTracks(Int_t iV) const{
705 // Get pile-up vertex iV
706 Int_t nVertices=GetNumberOfVertices();
707 Int_t counter=0;
708 for(Int_t iVert=0; iVert<nVertices; iVert++){
709 AliAODVertex *v=GetVertex(iVert);
710 if(v->GetType()==AliAODVertex::kPileupTracks){
711 if(counter==iV) return v;
712 ++counter;
713 }
714 }
715 return 0;
716}
717//______________________________________________________________________________
718Bool_t AliAODEvent::IsPileupFromSPD(Int_t minContributors,
719 Double_t minZdist,
720 Double_t nSigmaZdist,
721 Double_t nSigmaDiamXY,
722 Double_t nSigmaDiamZ) const{
723 //
724 // This function checks if there was a pile up
725 // reconstructed with SPD
726 //
727 AliAODVertex *mainV=GetPrimaryVertexSPD();
728 if(!mainV) return kFALSE;
729 Int_t nc1=mainV->GetNContributors();
730 if(nc1<1) return kFALSE;
731 Int_t nPileVert=GetNumberOfPileupVerticesSPD();
732 if(nPileVert==0) return kFALSE;
733 Int_t nVertices=GetNumberOfVertices();
734
735 for(Int_t iVert=0; iVert<nVertices; iVert++){
736 AliAODVertex *pv=GetVertex(iVert);
737 if(pv->GetType()!=AliAODVertex::kPileupSPD) continue;
738 Int_t nc2=pv->GetNContributors();
739 if(nc2>=minContributors){
740 Double_t z1=mainV->GetZ();
741 Double_t z2=pv->GetZ();
742 Double_t distZ=TMath::Abs(z2-z1);
743 Double_t distZdiam=TMath::Abs(z2-GetDiamondZ());
744 Double_t cutZdiam=nSigmaDiamZ*TMath::Sqrt(GetSigma2DiamondZ());
745 if(GetSigma2DiamondZ()<0.0001)cutZdiam=99999.; //protection for missing z diamond information
746 if(distZ>minZdist && distZdiam<cutZdiam){
747 Double_t x2=pv->GetX();
748 Double_t y2=pv->GetY();
749 Double_t distXdiam=TMath::Abs(x2-GetDiamondX());
750 Double_t distYdiam=TMath::Abs(y2-GetDiamondY());
751 Double_t cov1[6],cov2[6];
752 mainV->GetCovarianceMatrix(cov1);
753 pv->GetCovarianceMatrix(cov2);
754 Double_t errxDist=TMath::Sqrt(cov2[0]+GetSigma2DiamondX());
755 Double_t erryDist=TMath::Sqrt(cov2[2]+GetSigma2DiamondY());
756 Double_t errzDist=TMath::Sqrt(cov1[5]+cov2[5]);
757 Double_t cutXdiam=nSigmaDiamXY*errxDist;
758 if(GetSigma2DiamondX()<0.0001)cutXdiam=99999.; //protection for missing diamond information
759 Double_t cutYdiam=nSigmaDiamXY*erryDist;
760 if(GetSigma2DiamondY()<0.0001)cutYdiam=99999.; //protection for missing diamond information
761 if( (distXdiam<cutXdiam) && (distYdiam<cutYdiam) && (distZ>nSigmaZdist*errzDist) ){
762 return kTRUE;
763 }
764 }
765 }
766 }
767 return kFALSE;
768}
769
770//______________________________________________________________________________
771void AliAODEvent::Print(Option_t *) const
772{
773 // Print the names of the all branches
774 TIter next(fAODObjects);
775 TNamed *el;
776 Printf(">>>>> AOD Content <<<<<");
777 while((el=(TNamed*)next())){
778 Printf(">> %s ",el->GetName());
779 }
780 Printf(">>>>> <<<<<");
781
782 return;
783}
784
785void AliAODEvent::AssignIDtoCollection(const TCollection* col)
786{
787 // Static method which assigns a ID to each object in a collection
788 // In this way the objects are marked as referenced and written with
789 // an ID. This has the advantage that TRefs to this objects can be
790 // written by a subsequent process.
791 TIter next(col);
792 TObject* obj;
793 while ((obj = next()))
794 TProcessID::AssignID(obj);
795}
796
797Bool_t AliAODEvent::IsPileupFromSPDInMultBins() const {
798 Int_t nTracklets=GetTracklets()->GetNumberOfTracklets();
799 if(nTracklets<20) return IsPileupFromSPD(3,0.8);
800 else if(nTracklets<50) return IsPileupFromSPD(4,0.8);
801 else return IsPileupFromSPD(5,0.8);
802}
803