]> git.uio.no Git - u/mrichter/AliRoot.git/blame - STEER/AliAODEvent.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Updates (Chiara)
[u/mrichter/AliRoot.git] / STEER / AliAODEvent.cxx
CommitLineData
df9db588 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
5c1dc41f 23#include <TROOT.h>
ec4af4c1 24#include <TTree.h>
5c1dc41f 25#include <TFolder.h>
298d3d58 26#include <TFriendElement.h>
c8e4f399 27#include <TProcessID.h>
28#include <TCollection.h>
a0df0b6a 29#include "Riostream.h"
df9db588 30#include "AliAODEvent.h"
31#include "AliAODHeader.h"
32#include "AliAODTrack.h"
866d8d78 33#include "AliAODDimuon.h"
df9db588 34
35ClassImp(AliAODEvent)
36
08e4c457 37// definition of std AOD member names
38 const char* AliAODEvent::fAODListName[kAODListN] = {"header",
39 "tracks",
40 "vertices",
3dd9f9e3 41 "v0s",
9a244178 42 "cascades",
3dd9f9e3 43 "tracklets",
08e4c457 44 "jets",
37792174 45 "emcalCells",
46 "phosCells",
3dd9f9e3 47 "caloClusters",
48 "fmdClusters",
866d8d78 49 "pmdClusters",
ae2bccf1 50 "dimuons",
51 "AliAODVZERO"
9a244178 52
3dd9f9e3 53};
df9db588 54//______________________________________________________________________________
55AliAODEvent::AliAODEvent() :
08e4c457 56 AliVEvent(),
df9db588 57 fAODObjects(new TList()),
5c1dc41f 58 fAODFolder(0),
dd389a30 59 fConnected(kFALSE),
ec4af4c1 60 fHeader(0),
61 fTracks(0),
62 fVertices(0),
3dd9f9e3 63 fV0s(0),
9a244178 64 fCascades(0),
3dd9f9e3 65 fTracklets(0),
821f8f1d 66 fJets(0),
37792174 67 fEmcalCells(0),
68 fPhosCells(0),
3dd9f9e3 69 fCaloClusters(0),
70 fFmdClusters(0),
866d8d78 71 fPmdClusters(0),
ae2bccf1 72 fDimuons(0),
73 fAODVZERO(0)
df9db588 74{
75 // default constructor
76}
77
5c1dc41f 78//______________________________________________________________________________
79AliAODEvent::AliAODEvent(const AliAODEvent& aod):
80 AliVEvent(aod),
81 fAODObjects(new TList()),
b752604b 82 fAODFolder(0),
dd389a30 83 fConnected(kFALSE),
5c1dc41f 84 fHeader(new AliAODHeader(*aod.fHeader)),
85 fTracks(new TClonesArray(*aod.fTracks)),
86 fVertices(new TClonesArray(*aod.fVertices)),
87 fV0s(new TClonesArray(*aod.fV0s)),
9a244178 88 fCascades(new TClonesArray(*aod.fCascades)),
5c1dc41f 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)),
866d8d78 95 fPmdClusters(new TClonesArray(*aod.fPmdClusters)),
ae2bccf1 96 fDimuons(new TClonesArray(*aod.fDimuons)),
97 fAODVZERO(new AliAODVZERO(*aod.fAODVZERO))
5c1dc41f 98{
99 // Copy constructor
100 AddObject(fHeader);
101 AddObject(fTracks);
102 AddObject(fVertices);
103 AddObject(fV0s);
9a244178 104 AddObject(fCascades);
5c1dc41f 105 AddObject(fTracklets);
106 AddObject(fJets);
107 AddObject(fEmcalCells);
108 AddObject(fPhosCells);
109 AddObject(fCaloClusters);
110 AddObject(fFmdClusters);
111 AddObject(fPmdClusters);
866d8d78 112 AddObject(fDimuons);
ae2bccf1 113 AddObject(fAODVZERO);
dd389a30 114 fConnected = aod.fConnected;
5c1dc41f 115 GetStdContent();
48f1c230 116 CreateStdFolders();
5c1dc41f 117}
118
119//______________________________________________________________________________
120AliAODEvent & AliAODEvent::operator=(const AliAODEvent& aod) {
121
122 // Assignment operator
123
48f1c230 124 if(&aod == this) return *this;
125 AliVEvent::operator=(aod);
5c1dc41f 126
48f1c230 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;
5c1dc41f 212}
213
214
df9db588 215//______________________________________________________________________________
216AliAODEvent::~AliAODEvent()
217{
ec4af4c1 218// destructor
dd389a30 219 if(fAODObjects&&!fConnected)
220 {
221 delete fAODObjects;
222 fAODObjects = 0;
223 }
224
5c1dc41f 225 delete fAODFolder;
b752604b 226 fAODFolder = 0;
df9db588 227}
228
229//______________________________________________________________________________
230void AliAODEvent::AddObject(TObject* obj)
231{
4b3de353 232 // Add an object to the list of objects.
df9db588 233 // Please be aware that in order to increase performance you should
234 // refrain from using TObjArrays (if possible). Use TClonesArrays, instead.
235
14d6fad5 236 if ( !fAODObjects->FindObject(obj) )
237 {
238 fAODObjects->AddLast(obj);
239 }
df9db588 240}
241
4b3de353 242//______________________________________________________________________________
243void AliAODEvent::RemoveObject(TObject* obj)
244{
245 // Removes an object from the list of objects.
246
247 fAODObjects->Remove(obj);
248}
249
df9db588 250//______________________________________________________________________________
2811495d 251TObject *AliAODEvent::FindListObject(const char *objName) const
df9db588 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));
3dd9f9e3 267 AddObject(new TClonesArray("AliAODv0", 0));
9a244178 268 AddObject(new TClonesArray("AliAODcascade", 0));
821f8f1d 269 AddObject(new AliAODTracklets());
3dd9f9e3 270 AddObject(new TClonesArray("AliAODJet", 0));
271 AddObject(new AliAODCaloCells());
37792174 272 AddObject(new AliAODCaloCells());
3dd9f9e3 273 AddObject(new TClonesArray("AliAODCaloCluster", 0));
274 AddObject(new TClonesArray("AliAODFmdCluster", 0));
275 AddObject(new TClonesArray("AliAODPmdCluster", 0));
866d8d78 276 AddObject(new TClonesArray("AliAODDimuon", 0));
ae2bccf1 277 AddObject(new AliAODVZERO());
08e4c457 278 // set names
279 SetStdNames();
280
df9db588 281 // read back pointers
282 GetStdContent();
5c1dc41f 283 CreateStdFolders();
08e4c457 284 return;
df9db588 285}
286
c8e4f399 287void AliAODEvent::MakeEntriesReferencable()
288{
289 // Make all entries referencable in a subsequent process
290 //
291 TIter next(fAODObjects);
292 TObject* obj;
8ac4fa64 293 while ((obj = next()))
c8e4f399 294 {
295 if(obj->InheritsFrom("TCollection"))
296 {
297 AssignIDtoCollection((TCollection*)obj);
298 }
299 }
300}
301
08e4c457 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
5c1dc41f 323void AliAODEvent::CreateStdFolders()
324{
325 // Create the standard folder structure
b752604b 326 if(fAODFolder)delete fAODFolder;
5c1dc41f 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
df9db588 343//______________________________________________________________________________
ec4af4c1 344void AliAODEvent::GetStdContent()
df9db588 345{
346 // set pointers for standard content
347
3dd9f9e3 348 fHeader = (AliAODHeader*)fAODObjects->FindObject("header");
349 fTracks = (TClonesArray*)fAODObjects->FindObject("tracks");
350 fVertices = (TClonesArray*)fAODObjects->FindObject("vertices");
351 fV0s = (TClonesArray*)fAODObjects->FindObject("v0s");
9a244178 352 fCascades = (TClonesArray*)fAODObjects->FindObject("cascades");
3dd9f9e3 353 fTracklets = (AliAODTracklets*)fAODObjects->FindObject("tracklets");
354 fJets = (TClonesArray*)fAODObjects->FindObject("jets");
37792174 355 fEmcalCells = (AliAODCaloCells*)fAODObjects->FindObject("emcalCells");
356 fPhosCells = (AliAODCaloCells*)fAODObjects->FindObject("phosCells");
3dd9f9e3 357 fCaloClusters = (TClonesArray*)fAODObjects->FindObject("caloClusters");
358 fFmdClusters = (TClonesArray*)fAODObjects->FindObject("fmdClusters");
359 fPmdClusters = (TClonesArray*)fAODObjects->FindObject("pmdClusters");
866d8d78 360 fDimuons = (TClonesArray*)fAODObjects->FindObject("dimuons");
ae2bccf1 361 fAODVZERO = (AliAODVZERO*)fAODObjects->FindObject("AliAODVZERO");
df9db588 362}
363
364//______________________________________________________________________________
3dd9f9e3 365void AliAODEvent::ResetStd(Int_t trkArrSize,
366 Int_t vtxArrSize,
9a244178 367 Int_t v0ArrSize,
368 Int_t cascadeArrSize,
3dd9f9e3 369 Int_t jetSize,
370 Int_t caloClusSize,
371 Int_t fmdClusSize,
866d8d78 372 Int_t pmdClusSize,
373 Int_t dimuonArrSize
9a244178 374 )
df9db588 375{
3dd9f9e3 376 // deletes content of standard arrays and resets size
9a244178 377
f8e407b9 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();
df9db588 429}
430
ec4af4c1 431void AliAODEvent::ClearStd()
432{
433 // clears the standard arrays
f8e407b9 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();
ec4af4c1 460}
461
78902954 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;
a0df0b6a 470 Bool_t first = kTRUE;
c8fe2783 471 for (Int_t i = 0; i < GetNumberOfCaloClusters() ; i++) {
78902954 472 if ( (cl = GetCaloCluster(i)) ) {
c8fe2783 473 if (cl->IsPHOS()){
a0df0b6a 474 if(first) {
475 new (clusters) TRefArray(TProcessID::GetProcessWithUID(cl));
476 first=kFALSE;
477 }
78902954 478 clusters->Add(cl);
a0df0b6a 479 //printf("IsPHOS cluster %d, E %2.3f Size: %d \n",i,cl->E(),clusters->GetEntriesFast());
78902954 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();
78902954 492 AliAODCaloCluster *cl = 0;
a0df0b6a 493 Bool_t first = kTRUE;
c8fe2783 494 for (Int_t i = 0; i < GetNumberOfCaloClusters(); i++) {
78902954 495 if ( (cl = GetCaloCluster(i)) ) {
c8fe2783 496 if (cl->IsEMCAL()){
a0df0b6a 497 if(first) {
498 new (clusters) TRefArray(TProcessID::GetProcessWithUID(cl));
499 first=kFALSE;
500 }
78902954 501 clusters->Add(cl);
a0df0b6a 502 //printf("IsEMCal cluster %d, E %2.3f Size: %d \n",i,cl->E(),clusters->GetEntriesFast());
78902954 503 }
504 }
505 }
506 return clusters->GetEntriesFast();
507}
508
509
fb41236c 510//______________________________________________________________________________
511Int_t AliAODEvent::GetMuonTracks(TRefArray *muonTracks) const
512{
513 // fills the provided TRefArray with all found muon tracks
df9db588 514
fb41236c 515 muonTracks->Clear();
df9db588 516
fb41236c 517 AliAODTrack *track = 0;
518 for (Int_t iTrack = 0; iTrack < GetNTracks(); iTrack++) {
11becff8 519 track = GetTrack(iTrack);
520 if (track->IsMuonTrack()) {
fb41236c 521 muonTracks->Add(track);
522 }
523 }
524
3dd9f9e3 525 return muonTracks->GetEntriesFast();
fb41236c 526}
ec4af4c1 527
528
fa8b0e56 529//______________________________________________________________________________
530Int_t AliAODEvent::GetNumberOfMuonTracks() const
531{
532 // get number of muon tracks
533 Int_t nMuonTracks=0;
fa8b0e56 534 for (Int_t iTrack = 0; iTrack < GetNTracks(); iTrack++) {
7ba6f91a 535 if ((GetTrack(iTrack))->IsMuonTrack()) {
fa8b0e56 536 nMuonTracks++;
537 }
538 }
539
540 return nMuonTracks;
541}
542
3b93c32a 543void AliAODEvent::ReadFromTree(TTree *tree, Option_t* opt /*= ""*/)
8ff33247 544{
c8fe2783 545 // Connects aod event to tree
08e4c457 546
61cb38c7 547 if(!tree){
548 Printf("%s %d AliAODEvent::ReadFromTree() Zero Pointer to Tree \n",(char*)__FILE__,__LINE__);
549 return;
550 }
c8fe2783 551 // load the TTree
61cb38c7 552 if(!tree->GetTree())tree->LoadTree(0);
c8fe2783 553
554 // Try to find AliAODEvent
61cb38c7 555 AliAODEvent *aodEvent = 0;
556 aodEvent = (AliAODEvent*)tree->GetTree()->GetUserInfo()->FindObject("AliAODEvent");
557 if(aodEvent){
c8fe2783 558 // Check if already connected to tree
61cb38c7 559 TList* connectedList = (TList*) (tree->GetUserInfo()->FindObject("AODObjectsConnectedToTree"));
3b93c32a 560 if (connectedList && (strcmp(opt, "reconnect"))) {
c8fe2783 561 // If connected use the connected list of objects
28a79204 562 fAODObjects->Delete();
563 fAODObjects = connectedList;
564 GetStdContent();
565 fConnected = kTRUE;
566 return;
d8f5fda5 567 }
c8fe2783 568 // Connect to tree
569 // prevent a memory leak when reading back the TList
28a79204 570// if (!(strcmp(opt, "reconnect"))) fAODObjects->Delete();
c8fe2783 571
572 // create a new TList from the UserInfo TList...
573 // copy constructor does not work...
61cb38c7 574 fAODObjects = (TList*)(aodEvent->GetList()->Clone());
316cf4cc 575 fAODObjects->SetOwner(kTRUE);
14d6fad5 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));
61cb38c7 580 }
c8fe2783 581 //
582 // Let's find out whether we have friends
ced57103 583 TList* friendL = tree->GetTree()->GetListOfFriends();
298d3d58 584 if (friendL)
585 {
c8fe2783 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
298d3d58 605 } // has friends
c8fe2783 606 // set the branch addresses
61cb38c7 607 TIter next(fAODObjects);
608 TNamed *el;
609 while((el=(TNamed*)next())){
610 TString bname(el->GetName());
c8fe2783 611 // check if branch exists under this Name
ced57103 612 TBranch *br = tree->GetTree()->GetBranch(bname.Data());
61cb38c7 613 if(br){
c8fe2783 614 tree->SetBranchAddress(bname.Data(),fAODObjects->GetObjectRef(el));
ced57103 615 } else {
c8fe2783 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 }
61cb38c7 624 }
625 }
61cb38c7 626 GetStdContent();
c8fe2783 627 // when reading back we are not owner of the list
628 // must not delete it
316cf4cc 629 fAODObjects->SetOwner(kTRUE);
61cb38c7 630 fAODObjects->SetName("AODObjectsConnectedToTree");
c8fe2783 631 // we are not owner of the list objects
632 // must not delete it
61cb38c7 633 tree->GetUserInfo()->Add(fAODObjects);
dd389a30 634 fConnected = kTRUE;
61cb38c7 635 }// no aodEvent
636 else {
c8fe2783 637 // we can't get the list from the user data, create standard content
638 // and set it by hand
61cb38c7 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();
c8fe2783 647 // when reading back we are not owner of the list
648 // must not delete it
316cf4cc 649 fAODObjects->SetOwner(kTRUE);
08e4c457 650 }
8ff33247 651}
c8fe2783 652 //______________________________________________________________________________
a98c78e5 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{
5e6a3170 676 // Get SPD primary vertex
a98c78e5 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{
5e6a3170 686 // Get pile-up vertex iV
a98c78e5 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{
5e6a3170 700 // Get pile-up vertex iV
a98c78e5 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());
569d954c 739 Double_t cutZdiam=nSigmaDiamZ*TMath::Sqrt(GetSigma2DiamondZ());
a98c78e5 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}
8ff33247 764
08e4c457 765//______________________________________________________________________________
766void AliAODEvent::Print(Option_t *) const
767{
4922c144 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(">>>>> <<<<<");
08e4c457 776
777 return;
778}
c8e4f399 779
5e6a3170 780void AliAODEvent::AssignIDtoCollection(const TCollection* col)
c8e4f399 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;
8ac4fa64 788 while ((obj = next()))
c8e4f399 789 TProcessID::AssignID(obj);
790}
b46ff4b0 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