]> git.uio.no Git - u/mrichter/AliRoot.git/blame_incremental - STEER/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
Updates (Chiara)
[u/mrichter/AliRoot.git] / STEER / 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
53};
54//______________________________________________________________________________
55AliAODEvent::AliAODEvent() :
56 AliVEvent(),
57 fAODObjects(new TList()),
58 fAODFolder(0),
59 fConnected(kFALSE),
60 fHeader(0),
61 fTracks(0),
62 fVertices(0),
63 fV0s(0),
64 fCascades(0),
65 fTracklets(0),
66 fJets(0),
67 fEmcalCells(0),
68 fPhosCells(0),
69 fCaloClusters(0),
70 fFmdClusters(0),
71 fPmdClusters(0),
72 fDimuons(0),
73 fAODVZERO(0)
74{
75 // default constructor
76}
77
78//______________________________________________________________________________
79AliAODEvent::AliAODEvent(const AliAODEvent& aod):
80 AliVEvent(aod),
81 fAODObjects(new TList()),
82 fAODFolder(0),
83 fConnected(kFALSE),
84 fHeader(new AliAODHeader(*aod.fHeader)),
85 fTracks(new TClonesArray(*aod.fTracks)),
86 fVertices(new TClonesArray(*aod.fVertices)),
87 fV0s(new TClonesArray(*aod.fV0s)),
88 fCascades(new TClonesArray(*aod.fCascades)),
89 fTracklets(new AliAODTracklets(*aod.fTracklets)),
90 fJets(new TClonesArray(*aod.fJets)),
91 fEmcalCells(new AliAODCaloCells(*aod.fEmcalCells)),
92 fPhosCells(new AliAODCaloCells(*aod.fPhosCells)),
93 fCaloClusters(new TClonesArray(*aod.fCaloClusters)),
94 fFmdClusters(new TClonesArray(*aod.fFmdClusters)),
95 fPmdClusters(new TClonesArray(*aod.fPmdClusters)),
96 fDimuons(new TClonesArray(*aod.fDimuons)),
97 fAODVZERO(new AliAODVZERO(*aod.fAODVZERO))
98{
99 // Copy constructor
100 AddObject(fHeader);
101 AddObject(fTracks);
102 AddObject(fVertices);
103 AddObject(fV0s);
104 AddObject(fCascades);
105 AddObject(fTracklets);
106 AddObject(fJets);
107 AddObject(fEmcalCells);
108 AddObject(fPhosCells);
109 AddObject(fCaloClusters);
110 AddObject(fFmdClusters);
111 AddObject(fPmdClusters);
112 AddObject(fDimuons);
113 AddObject(fAODVZERO);
114 fConnected = aod.fConnected;
115 GetStdContent();
116 CreateStdFolders();
117}
118
119//______________________________________________________________________________
120AliAODEvent & AliAODEvent::operator=(const AliAODEvent& aod) {
121
122 // Assignment operator
123
124 if(&aod == this) return *this;
125 AliVEvent::operator=(aod);
126
127 // This assumes that the list is already created
128 // and that the virtual void Copy(Tobject&) function
129 // is correctly implemented in the derived class
130 // otherwise only TObject::Copy() will be used
131
132 if((fAODObjects->GetSize()==0)&&(aod.fAODObjects->GetSize()>=kAODListN)){
133 // We cover the case that we do not yet have the
134 // standard content but the source has it
135 CreateStdContent();
136 }
137
138 // Here we have the standard content without user additions, but the content is
139 // not matching the aod source.
140
141 // Iterate the list of source objects
142 TIter next(aod.GetList());
143 TObject *its = 0;
144 TString name;
145 while ((its = next())) {
146 name = its->GetName();
147 // Check if we have this object type in out list
148 TObject *mine = fAODObjects->FindObject(name);
149 if(!mine) {
150 // We have to create the same type of object.
151 TClass* pClass=TClass::GetClass(its->ClassName());
152 if (!pClass) {
153 AliWarning(Form("Can not find class description for entry %s (%s)\n",
154 its->ClassName(), name.Data()));
155 continue;
156 }
157 mine=(TObject*)pClass->New();
158 if(!mine){
159 // not in this: can be added to list
160 AliWarning(Form("%s:%d Could not find %s for copying \n",
161 (char*)__FILE__,__LINE__,name.Data()));
162 continue;
163 }
164 if(mine->InheritsFrom("TNamed")) {
165 ((TNamed*)mine)->SetName(name);
166 } else if(mine->InheritsFrom("TCollection")){
167 if(mine->InheritsFrom("TClonesArray")) {
168 TClonesArray *itscl = dynamic_cast<TClonesArray*>(its);
169 if (!itscl) {
170 AliWarning(Form("Class description for entry %s (%s) not TClonesArray\n",
171 its->ClassName(), name.Data()));
172 continue;
173
174 }
175 dynamic_cast<TClonesArray*>(mine)->SetClass(itscl->GetClass(), itscl->GetSize());
176 }
177 dynamic_cast<TCollection*>(mine)->SetName(name);
178 }
179 AliDebug(1, Form("adding object %s of type %s", mine->GetName(), mine->ClassName()));
180 AddObject(mine);
181 }
182 // Now we have an object of the same type and name, but different content.
183 if(!its->InheritsFrom("TCollection")){
184 // simple objects (do they have a Copy method that calls operator= ?)
185 its->Copy(*mine);
186 } else if (its->InheritsFrom("TClonesArray")) {
187 // Create or expand the tclonesarray pointers
188 // so we can directly copy to the object
189 TClonesArray *its_tca = (TClonesArray*)its;
190 TClonesArray *mine_tca = (TClonesArray*)mine;
191 // this leaves the capacity of the TClonesArray the same
192 // except for a factor of 2 increase when size > capacity
193 // does not release any memory occupied by the tca
194 Int_t its_entries = its_tca->GetEntriesFast();
195 mine_tca->ExpandCreate(its_entries);
196 for(int i=0; i<its_entries; i++){
197 // copy
198 TObject *mine_tca_obj = mine_tca->At(i);
199 TObject *its_tca_obj = its_tca->At(i);
200 // no need to delete first
201 // pointers within the class should be handled by Copy()...
202 // Can there be Empty slots?
203 its_tca_obj->Copy(*mine_tca_obj);
204 }
205 } else {
206 AliWarning(Form("%s:%d cannot copy TCollection \n",
207 (char*)__FILE__,__LINE__));
208 }
209 }
210 fConnected = aod.fConnected;
211 return *this;
212}
213
214
215//______________________________________________________________________________
216AliAODEvent::~AliAODEvent()
217{
218// destructor
219 if(fAODObjects&&!fConnected)
220 {
221 delete fAODObjects;
222 fAODObjects = 0;
223 }
224
225 delete fAODFolder;
226 fAODFolder = 0;
227}
228
229//______________________________________________________________________________
230void AliAODEvent::AddObject(TObject* obj)
231{
232 // Add an object to the list of objects.
233 // Please be aware that in order to increase performance you should
234 // refrain from using TObjArrays (if possible). Use TClonesArrays, instead.
235
236 if ( !fAODObjects->FindObject(obj) )
237 {
238 fAODObjects->AddLast(obj);
239 }
240}
241
242//______________________________________________________________________________
243void AliAODEvent::RemoveObject(TObject* obj)
244{
245 // Removes an object from the list of objects.
246
247 fAODObjects->Remove(obj);
248}
249
250//______________________________________________________________________________
251TObject *AliAODEvent::FindListObject(const char *objName) const
252{
253 // Return the pointer to the object with the given name.
254
255 return fAODObjects->FindObject(objName);
256}
257
258//______________________________________________________________________________
259void AliAODEvent::CreateStdContent()
260{
261 // create the standard AOD content and set pointers
262
263 // create standard objects and add them to the TList of objects
264 AddObject(new AliAODHeader());
265 AddObject(new TClonesArray("AliAODTrack", 0));
266 AddObject(new TClonesArray("AliAODVertex", 0));
267 AddObject(new TClonesArray("AliAODv0", 0));
268 AddObject(new TClonesArray("AliAODcascade", 0));
269 AddObject(new AliAODTracklets());
270 AddObject(new TClonesArray("AliAODJet", 0));
271 AddObject(new AliAODCaloCells());
272 AddObject(new AliAODCaloCells());
273 AddObject(new TClonesArray("AliAODCaloCluster", 0));
274 AddObject(new TClonesArray("AliAODFmdCluster", 0));
275 AddObject(new TClonesArray("AliAODPmdCluster", 0));
276 AddObject(new TClonesArray("AliAODDimuon", 0));
277 AddObject(new AliAODVZERO());
278 // set names
279 SetStdNames();
280
281 // read back pointers
282 GetStdContent();
283 CreateStdFolders();
284 return;
285}
286
287void AliAODEvent::MakeEntriesReferencable()
288{
289 // Make all entries referencable in a subsequent process
290 //
291 TIter next(fAODObjects);
292 TObject* obj;
293 while ((obj = next()))
294 {
295 if(obj->InheritsFrom("TCollection"))
296 {
297 AssignIDtoCollection((TCollection*)obj);
298 }
299 }
300}
301
302//______________________________________________________________________________
303void AliAODEvent::SetStdNames()
304{
305 // introduce the standard naming
306
307 if(fAODObjects->GetEntries()==kAODListN){
308 for(int i = 0;i < fAODObjects->GetEntries();i++){
309 TObject *fObj = fAODObjects->At(i);
310 if(fObj->InheritsFrom("TNamed")){
311 ((TNamed*)fObj)->SetName(fAODListName[i]);
312 }
313 else if(fObj->InheritsFrom("TClonesArray")){
314 ((TClonesArray*)fObj)->SetName(fAODListName[i]);
315 }
316 }
317 }
318 else{
319 printf("%s:%d SetStdNames() Wrong number of Std Entries \n",(char*)__FILE__,__LINE__);
320 }
321}
322
323void AliAODEvent::CreateStdFolders()
324{
325 // Create the standard folder structure
326 if(fAODFolder)delete fAODFolder;
327 fAODFolder = gROOT->GetRootFolder()->AddFolder("AOD", "AOD");
328 if(fAODObjects->GetEntries()==kAODListN){
329 for(int i = 0;i < fAODObjects->GetEntries();i++){
330 TObject *fObj = fAODObjects->At(i);
331 if(fObj->InheritsFrom("TClonesArray")){
332 fAODFolder->AddFolder(fAODListName[i], fAODListName[i], (TCollection*) fObj);
333 } else {
334 fAODFolder->AddFolder(fAODListName[i], fAODListName[i], 0);
335 }
336 }
337 }
338 else{
339 printf("%s:%d CreateStdFolders() Wrong number of Std Entries \n",(char*)__FILE__,__LINE__);
340 }
341}
342
343//______________________________________________________________________________
344void AliAODEvent::GetStdContent()
345{
346 // set pointers for standard content
347
348 fHeader = (AliAODHeader*)fAODObjects->FindObject("header");
349 fTracks = (TClonesArray*)fAODObjects->FindObject("tracks");
350 fVertices = (TClonesArray*)fAODObjects->FindObject("vertices");
351 fV0s = (TClonesArray*)fAODObjects->FindObject("v0s");
352 fCascades = (TClonesArray*)fAODObjects->FindObject("cascades");
353 fTracklets = (AliAODTracklets*)fAODObjects->FindObject("tracklets");
354 fJets = (TClonesArray*)fAODObjects->FindObject("jets");
355 fEmcalCells = (AliAODCaloCells*)fAODObjects->FindObject("emcalCells");
356 fPhosCells = (AliAODCaloCells*)fAODObjects->FindObject("phosCells");
357 fCaloClusters = (TClonesArray*)fAODObjects->FindObject("caloClusters");
358 fFmdClusters = (TClonesArray*)fAODObjects->FindObject("fmdClusters");
359 fPmdClusters = (TClonesArray*)fAODObjects->FindObject("pmdClusters");
360 fDimuons = (TClonesArray*)fAODObjects->FindObject("dimuons");
361 fAODVZERO = (AliAODVZERO*)fAODObjects->FindObject("AliAODVZERO");
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
543void AliAODEvent::ReadFromTree(TTree *tree, Option_t* opt /*= ""*/)
544{
545 // Connects aod event to tree
546
547 if(!tree){
548 Printf("%s %d AliAODEvent::ReadFromTree() Zero Pointer to Tree \n",(char*)__FILE__,__LINE__);
549 return;
550 }
551 // load the TTree
552 if(!tree->GetTree())tree->LoadTree(0);
553
554 // Try to find AliAODEvent
555 AliAODEvent *aodEvent = 0;
556 aodEvent = (AliAODEvent*)tree->GetTree()->GetUserInfo()->FindObject("AliAODEvent");
557 if(aodEvent){
558 // Check if already connected to tree
559 TList* connectedList = (TList*) (tree->GetUserInfo()->FindObject("AODObjectsConnectedToTree"));
560 if (connectedList && (strcmp(opt, "reconnect"))) {
561 // If connected use the connected list of objects
562 fAODObjects->Delete();
563 fAODObjects = connectedList;
564 GetStdContent();
565 fConnected = kTRUE;
566 return;
567 }
568 // Connect to tree
569 // prevent a memory leak when reading back the TList
570// if (!(strcmp(opt, "reconnect"))) fAODObjects->Delete();
571
572 // create a new TList from the UserInfo TList...
573 // copy constructor does not work...
574 fAODObjects = (TList*)(aodEvent->GetList()->Clone());
575 fAODObjects->SetOwner(kTRUE);
576 if(fAODObjects->GetEntries()<kAODListN)
577 {
578 AliWarning(Form("AliAODEvent::ReadFromTree() TList contains less than the standard contents %d < %d"
579 " That might be fine though (at least for filtered AODs)",fAODObjects->GetEntries(),kAODListN));
580 }
581 //
582 // Let's find out whether we have friends
583 TList* friendL = tree->GetTree()->GetListOfFriends();
584 if (friendL)
585 {
586 TIter next(friendL);
587 TFriendElement* fe;
588 while ((fe = (TFriendElement*)next())){
589 aodEvent = (AliAODEvent*)(fe->GetTree()->GetUserInfo()->FindObject("AliAODEvent"));
590 if (!aodEvent) {
591 printf("No UserInfo on tree \n");
592 } else {
593
594 TList* objL = (TList*)(aodEvent->GetList()->Clone());
595 printf("Get list of object from tree %d !!\n", objL->GetEntries());
596 TIter nextobject(objL);
597 TObject* obj = 0;
598 while((obj = nextobject()))
599 {
600 printf("Adding object from friend %s !\n", obj->GetName());
601 fAODObjects->Add(obj);
602 } // object "branch" loop
603 } // has userinfo
604 } // friend loop
605 } // has friends
606 // set the branch addresses
607 TIter next(fAODObjects);
608 TNamed *el;
609 while((el=(TNamed*)next())){
610 TString bname(el->GetName());
611 // check if branch exists under this Name
612 TBranch *br = tree->GetTree()->GetBranch(bname.Data());
613 if(br){
614 tree->SetBranchAddress(bname.Data(),fAODObjects->GetObjectRef(el));
615 } else {
616 br = tree->GetBranch(Form("%s.",bname.Data()));
617 if(br){
618 tree->SetBranchAddress(Form("%s.",bname.Data()),fAODObjects->GetObjectRef(el));
619 }
620 else{
621 printf("%s %d AliAODEvent::ReadFromTree() No Branch found with Name %s. \n",
622 (char*)__FILE__,__LINE__,bname.Data());
623 }
624 }
625 }
626 GetStdContent();
627 // when reading back we are not owner of the list
628 // must not delete it
629 fAODObjects->SetOwner(kTRUE);
630 fAODObjects->SetName("AODObjectsConnectedToTree");
631 // we are not owner of the list objects
632 // must not delete it
633 tree->GetUserInfo()->Add(fAODObjects);
634 fConnected = kTRUE;
635 }// no aodEvent
636 else {
637 // we can't get the list from the user data, create standard content
638 // and set it by hand
639 CreateStdContent();
640 TIter next(fAODObjects);
641 TNamed *el;
642 while((el=(TNamed*)next())){
643 TString bname(el->GetName());
644 tree->SetBranchAddress(bname.Data(),fAODObjects->GetObjectRef(el));
645 }
646 GetStdContent();
647 // when reading back we are not owner of the list
648 // must not delete it
649 fAODObjects->SetOwner(kTRUE);
650 }
651}
652 //______________________________________________________________________________
653Int_t AliAODEvent::GetNumberOfPileupVerticesSPD() const{
654 // count number of SPD pileup vertices
655 Int_t nVertices=GetNumberOfVertices();
656 Int_t nPileupVertices=0;
657 for(Int_t iVert=0; iVert<nVertices; iVert++){
658 AliAODVertex *v=GetVertex(iVert);
659 if(v->GetType()==AliAODVertex::kPileupSPD) nPileupVertices++;
660 }
661 return nPileupVertices;
662}
663//______________________________________________________________________________
664Int_t AliAODEvent::GetNumberOfPileupVerticesTracks() const{
665 // count number of track pileup vertices
666 Int_t nVertices=GetNumberOfVertices();
667 Int_t nPileupVertices=0;
668 for(Int_t iVert=0; iVert<nVertices; iVert++){
669 AliAODVertex *v=GetVertex(iVert);
670 if(v->GetType()==AliAODVertex::kPileupTracks) nPileupVertices++;
671 }
672 return nPileupVertices;
673}
674//______________________________________________________________________________
675AliAODVertex* AliAODEvent::GetPrimaryVertexSPD() const{
676 // Get SPD primary vertex
677 Int_t nVertices=GetNumberOfVertices();
678 for(Int_t iVert=0; iVert<nVertices; iVert++){
679 AliAODVertex *v=GetVertex(iVert);
680 if(v->GetType()==AliAODVertex::kMainSPD) return v;
681 }
682 return 0;
683}
684//______________________________________________________________________________
685AliAODVertex* AliAODEvent::GetPileupVertexSPD(Int_t iV) const{
686 // Get pile-up vertex iV
687 Int_t nVertices=GetNumberOfVertices();
688 Int_t counter=0;
689 for(Int_t iVert=0; iVert<nVertices; iVert++){
690 AliAODVertex *v=GetVertex(iVert);
691 if(v->GetType()==AliAODVertex::kPileupSPD){
692 if(counter==iV) return v;
693 ++counter;
694 }
695 }
696 return 0;
697}
698//______________________________________________________________________________
699AliAODVertex* AliAODEvent::GetPileupVertexTracks(Int_t iV) const{
700 // Get pile-up vertex iV
701 Int_t nVertices=GetNumberOfVertices();
702 Int_t counter=0;
703 for(Int_t iVert=0; iVert<nVertices; iVert++){
704 AliAODVertex *v=GetVertex(iVert);
705 if(v->GetType()==AliAODVertex::kPileupTracks){
706 if(counter==iV) return v;
707 ++counter;
708 }
709 }
710 return 0;
711}
712//______________________________________________________________________________
713Bool_t AliAODEvent::IsPileupFromSPD(Int_t minContributors,
714 Double_t minZdist,
715 Double_t nSigmaZdist,
716 Double_t nSigmaDiamXY,
717 Double_t nSigmaDiamZ) const{
718 //
719 // This function checks if there was a pile up
720 // reconstructed with SPD
721 //
722 AliAODVertex *mainV=GetPrimaryVertexSPD();
723 if(!mainV) return kFALSE;
724 Int_t nc1=mainV->GetNContributors();
725 if(nc1<1) return kFALSE;
726 Int_t nPileVert=GetNumberOfPileupVerticesSPD();
727 if(nPileVert==0) return kFALSE;
728 Int_t nVertices=GetNumberOfVertices();
729
730 for(Int_t iVert=0; iVert<nVertices; iVert++){
731 AliAODVertex *pv=GetVertex(iVert);
732 if(pv->GetType()!=AliAODVertex::kPileupSPD) continue;
733 Int_t nc2=pv->GetNContributors();
734 if(nc2>=minContributors){
735 Double_t z1=mainV->GetZ();
736 Double_t z2=pv->GetZ();
737 Double_t distZ=TMath::Abs(z2-z1);
738 Double_t distZdiam=TMath::Abs(z2-GetDiamondZ());
739 Double_t cutZdiam=nSigmaDiamZ*TMath::Sqrt(GetSigma2DiamondZ());
740 if(GetSigma2DiamondZ()<0.0001)cutZdiam=99999.; //protection for missing z diamond information
741 if(distZ>minZdist && distZdiam<cutZdiam){
742 Double_t x2=pv->GetX();
743 Double_t y2=pv->GetY();
744 Double_t distXdiam=TMath::Abs(x2-GetDiamondX());
745 Double_t distYdiam=TMath::Abs(y2-GetDiamondY());
746 Double_t cov1[6],cov2[6];
747 mainV->GetCovarianceMatrix(cov1);
748 pv->GetCovarianceMatrix(cov2);
749 Double_t errxDist=TMath::Sqrt(cov2[0]+GetSigma2DiamondX());
750 Double_t erryDist=TMath::Sqrt(cov2[2]+GetSigma2DiamondY());
751 Double_t errzDist=TMath::Sqrt(cov1[5]+cov2[5]);
752 Double_t cutXdiam=nSigmaDiamXY*errxDist;
753 if(GetSigma2DiamondX()<0.0001)cutXdiam=99999.; //protection for missing diamond information
754 Double_t cutYdiam=nSigmaDiamXY*erryDist;
755 if(GetSigma2DiamondY()<0.0001)cutYdiam=99999.; //protection for missing diamond information
756 if( (distXdiam<cutXdiam) && (distYdiam<cutYdiam) && (distZ>nSigmaZdist*errzDist) ){
757 return kTRUE;
758 }
759 }
760 }
761 }
762 return kFALSE;
763}
764
765//______________________________________________________________________________
766void AliAODEvent::Print(Option_t *) const
767{
768 // Print the names of the all branches
769 TIter next(fAODObjects);
770 TNamed *el;
771 Printf(">>>>> AOD Content <<<<<");
772 while((el=(TNamed*)next())){
773 Printf(">> %s ",el->GetName());
774 }
775 Printf(">>>>> <<<<<");
776
777 return;
778}
779
780void AliAODEvent::AssignIDtoCollection(const TCollection* col)
781{
782 // Static method which assigns a ID to each object in a collection
783 // In this way the objects are marked as referenced and written with
784 // an ID. This has the advantage that TRefs to this objects can be
785 // written by a subsequent process.
786 TIter next(col);
787 TObject* obj;
788 while ((obj = next()))
789 TProcessID::AssignID(obj);
790}
791
792Bool_t AliAODEvent::IsPileupFromSPDInMultBins() const {
793 Int_t nTracklets=GetTracklets()->GetNumberOfTracklets();
794 if(nTracklets<20) return IsPileupFromSPD(3,0.8);
795 else if(nTracklets<50) return IsPileupFromSPD(4,0.8);
796 else return IsPileupFromSPD(5,0.8);
797}
798