1 /**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
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 **************************************************************************/
18 //-----------------------------------------------------------------
19 // Implementation of the AliESDEvent class
20 // This is the class to deal with during the phisical analysis of data.
21 // It also ensures the backward compatibility with the old ESD format.
23 // Origin: Christian Klein-Boesing, CERN, Christian.Klein-Boesing@cern.ch
24 //-----------------------------------------------------------------
29 #include "AliESDEvent.h"
30 #include "AliESDfriend.h"
31 #include "AliESDVZERO.h"
32 #include "AliESDHLTtrack.h"
33 #include "AliESDFMD.h"
41 // here we define the names, some classes are no TNamed, therefore the classnames
43 const char* AliESDEvent::fESDListName[kESDListN] = {"AliESDRun",
62 "AliRawDataErrorLogs"};
63 //______________________________________________________________________________
64 AliESDEvent::AliESDEvent():
65 fESDObjects(new TList()),
89 fFirstEMCALCluster(-1),
94 //______________________________________________________________________________
95 AliESDEvent::AliESDEvent(const AliESDEvent& esd):
97 fESDObjects(new TList()),
98 fESDRun(new AliESDRun(*esd.fESDRun)),
99 fHeader(new AliESDHeader(*esd.fHeader)),
100 fESDZDC(new AliESDZDC(*esd.fESDZDC)),
101 fESDFMD(new AliESDFMD(*esd.fESDFMD)),
102 fESDVZERO(new AliESDVZERO(*esd.fESDVZERO)),
103 fESDTZERO(new AliESDTZERO(*esd.fESDTZERO)),
104 fSPDVertex(new AliESDVertex(*esd.fSPDVertex)),
105 fPrimaryVertex(new AliESDVertex(*esd.fPrimaryVertex)),
106 fSPDMult(new AliMultiplicity(*esd.fSPDMult)),
107 fPHOSTrigger(new AliESDCaloTrigger(*esd.fPHOSTrigger)),
108 fEMCALTrigger(new AliESDCaloTrigger(*esd.fEMCALTrigger)),
109 fTracks(new TClonesArray(*esd.fTracks)),
110 fMuonTracks(new TClonesArray(*esd.fMuonTracks)),
111 fPmdTracks(new TClonesArray(*esd.fPmdTracks)),
112 fTrdTracks(new TClonesArray(*esd.fTrdTracks)),
113 fV0s(new TClonesArray(*esd.fV0s)),
114 fCascades(new TClonesArray(*esd.fCascades)),
115 fKinks(new TClonesArray(*esd.fKinks)),
116 fCaloClusters(new TClonesArray(*esd.fCaloClusters)),
117 fErrorLogs(new TClonesArray(*esd.fErrorLogs)),
118 fESDOld(new AliESD(*esd.fESDOld)),
119 fConnected(esd.fConnected),
120 fEMCALClusters(esd.fEMCALClusters),
121 fFirstEMCALCluster(esd.fFirstEMCALCluster),
122 fPHOSClusters(esd.fPHOSClusters),
123 fFirstPHOSCluster(esd.fFirstPHOSCluster)
126 // CKB init in the constructor list and only add here ...
131 AddObject(fESDVZERO);
132 AddObject(fESDTZERO);
133 AddObject(fSPDVertex);
134 AddObject(fPrimaryVertex);
136 AddObject(fPHOSTrigger);
137 AddObject(fEMCALTrigger);
139 AddObject(fMuonTracks);
140 AddObject(fPmdTracks);
141 AddObject(fTrdTracks);
143 AddObject(fCascades);
145 AddObject(fCaloClusters);
146 AddObject(fErrorLogs);
152 //______________________________________________________________________________
153 AliESDEvent & AliESDEvent::operator=(const AliESDEvent& source) {
155 // Assignment operator
157 if(&source == this) return *this;
158 TObject::operator=(source);
160 fESDRun = new AliESDRun(*source.fESDRun);
161 fHeader = new AliESDHeader(*source.fHeader);
162 fESDZDC = new AliESDZDC(*source.fESDZDC);
163 fESDFMD = new AliESDFMD(*source.fESDFMD);
164 fESDVZERO = new AliESDVZERO(*source.fESDVZERO);
165 fESDTZERO = new AliESDTZERO(*source.fESDTZERO);
166 fSPDVertex = new AliESDVertex(*source.fSPDVertex);
167 fPrimaryVertex = new AliESDVertex(*source.fPrimaryVertex);
168 fSPDMult = new AliMultiplicity(*source.fSPDMult);
169 fPHOSTrigger = new AliESDCaloTrigger(*source.fPHOSTrigger);
170 fEMCALTrigger = new AliESDCaloTrigger(*source.fEMCALTrigger);
171 fTracks = new TClonesArray(*source.fTracks);
172 fMuonTracks = new TClonesArray(*source.fMuonTracks);
173 fPmdTracks = new TClonesArray(*source.fPmdTracks);
174 fTrdTracks = new TClonesArray(*source.fTrdTracks);
175 fV0s = new TClonesArray(*source.fV0s);
176 fCascades = new TClonesArray(*source.fCascades);
177 fKinks = new TClonesArray(*source.fKinks);
178 fCaloClusters = new TClonesArray(*source.fCaloClusters);
179 fErrorLogs = new TClonesArray(*source.fErrorLogs);
180 fESDOld = new AliESD(*source.fESDOld);
182 // or AddObject( fESDZDC = new AliESDZDC(*source.fESDZDC));
184 fESDObjects = new TList();
189 AddObject(fESDVZERO);
190 AddObject(fESDTZERO);
191 AddObject(fSPDVertex);
192 AddObject(fPrimaryVertex);
194 AddObject(fPHOSTrigger);
195 AddObject(fEMCALTrigger);
197 AddObject(fMuonTracks);
198 AddObject(fPmdTracks);
199 AddObject(fTrdTracks);
201 AddObject(fCascades);
203 AddObject(fCaloClusters);
204 AddObject(fErrorLogs);
206 fConnected = source.fConnected;
207 fEMCALClusters = source.fEMCALClusters;
208 fFirstEMCALCluster = source.fFirstEMCALCluster;
209 fPHOSClusters = source.fPHOSClusters;
210 fFirstPHOSCluster = source.fFirstPHOSCluster;
219 //______________________________________________________________________________
220 AliESDEvent::~AliESDEvent()
223 // Standard destructor
226 // everthing on the list gets deleted automatically
229 if(fESDObjects&&!fConnected)
238 //______________________________________________________________________________
239 void AliESDEvent::Reset()
243 // Reset the standard contents
246 if(fESDOld)fESDOld->Reset();
247 // call reset for user supplied data?
250 void AliESDEvent::ResetStdContent()
252 // Reset the standard contents
253 if(fESDRun) fESDRun->Reset();
254 if(fHeader) fHeader->Reset();
255 if(fESDZDC) fESDZDC->Reset();
256 if(fESDFMD) fESDFMD->Clear(); // why clear.... need consistend names
257 // if(fESDVZERO) fESDVZERO->; // NOT IMPLEMENTED
258 // if(fESDVZERO) new (fESDVZERO) AliESDVZERO();
259 if(fESDTZERO) fESDTZERO->Reset();
260 // CKB no clear/reset implemented
262 new (fSPDVertex) AliESDVertex();
263 fSPDVertex->SetName(fESDListName[kSPDVertex]);
266 new (fPrimaryVertex) AliESDVertex();
267 fPrimaryVertex->SetName(fESDListName[kPrimaryVertex]);
269 if(fSPDMult)new (fSPDMult) AliMultiplicity();
270 if(fPHOSTrigger)fPHOSTrigger->Reset();
271 if(fEMCALTrigger)fEMCALTrigger->Reset();
272 if(fTracks)fTracks->Clear();
273 if(fMuonTracks)fMuonTracks->Clear();
274 if(fPmdTracks)fPmdTracks->Clear();
275 if(fTrdTracks)fTrdTracks->Clear();
276 if(fV0s)fV0s->Clear();
277 if(fCascades)fCascades->Clear();
278 if(fKinks)fKinks->Clear();
279 if(fCaloClusters)fCaloClusters->Clear();
280 if(fErrorLogs) fErrorLogs->Clear();
282 // don't reset fconnected fConnected ;
285 fFirstEMCALCluster=-1;
287 fFirstPHOSCluster=-1;
291 Int_t AliESDEvent::AddV0(const AliESDv0 *v) {
295 TClonesArray &fv = *fV0s;
296 Int_t idx=fV0s->GetEntriesFast();
297 new(fv[idx]) AliESDv0(*v);
301 //______________________________________________________________________________
302 void AliESDEvent::Print(Option_t *) const
305 // Print header information of the event
307 printf("ESD run information\n");
308 printf("Event # in file %d Bunch crossing # %d Orbit # %d Period # %d Run # %d Trigger %lld Magnetic field %f \n",
309 GetEventNumberInFile(),
310 GetBunchCrossNumber(),
315 GetMagneticField() );
316 printf("Vertex: (%.4f +- %.4f, %.4f +- %.4f, %.4f +- %.4f) cm\n",
317 fPrimaryVertex->GetXv(), fPrimaryVertex->GetXRes(),
318 fPrimaryVertex->GetYv(), fPrimaryVertex->GetYRes(),
319 fPrimaryVertex->GetZv(), fPrimaryVertex->GetZRes());
320 printf("Mean vertex in RUN: X=%.4f Y=%.4f cm\n",
321 GetDiamondX(),GetDiamondY());
322 printf("SPD Multiplicity. Number of tracklets %d \n",
323 fSPDMult->GetNumberOfTracklets());
324 printf("Number of tracks: \n");
325 printf(" charged %d\n", GetNumberOfTracks());
326 printf(" muon %d\n", GetNumberOfMuonTracks());
327 printf(" pmd %d\n", GetNumberOfPmdTracks());
328 printf(" trd %d\n", GetNumberOfTrdTracks());
329 printf(" v0 %d\n", GetNumberOfV0s());
330 printf(" cascades %d\n", GetNumberOfCascades());
331 printf(" kinks %d\n", GetNumberOfKinks());
332 printf(" CaloClusters %d\n", GetNumberOfCaloClusters());
333 printf(" phos %d\n", GetNumberOfPHOSClusters());
334 printf(" emcal %d\n", GetNumberOfEMCALClusters());
335 printf(" FMD %s\n", (fESDFMD ? "yes" : "no"));
336 printf(" VZERO %s\n", (fESDVZERO ? "yes" : "no"));
339 void AliESDEvent::SetESDfriend(const AliESDfriend *ev) {
341 // Attaches the complementary info to the ESD
345 // to be sure that we set the tracks also
346 // in case of old esds
347 // if(fESDOld)CopyFromOldESD();
349 Int_t ntrk=ev->GetNumberOfTracks();
351 for (Int_t i=0; i<ntrk; i++) {
352 const AliESDfriendTrack *f=ev->GetTrack(i);
353 GetTrack(i)->SetFriendTrack(f);
357 Int_t AliESDEvent::AddTrack(const AliESDtrack *t) {
359 TClonesArray &ftr = *fTracks;
360 AliESDtrack * track = new(ftr[fTracks->GetEntriesFast()])AliESDtrack(*t);
361 track->SetID(fTracks->GetEntriesFast()-1);
362 return track->GetID();
365 Int_t AliESDEvent::AddKink(const AliESDkink *c) {
367 TClonesArray &fk = *fKinks;
368 AliESDkink * kink = new(fk[fKinks->GetEntriesFast()]) AliESDkink(*c);
369 kink->SetID(fKinks->GetEntriesFast()); // CKB different from the other imps..
370 return fKinks->GetEntriesFast()-1;
373 Int_t AliESDEvent::AddCaloCluster(const AliESDCaloCluster *c) {
375 TClonesArray &fc = *fCaloClusters;
376 AliESDCaloCluster *clus = new(fc[fCaloClusters->GetEntriesFast()]) AliESDCaloCluster(*c);
377 clus->SetID(fCaloClusters->GetEntriesFast()-1);
378 return fCaloClusters->GetEntriesFast()-1;
382 void AliESDEvent::SetVertex(const AliESDVertex *vertex) {
383 // use already allocated space
385 new(fSPDVertex) AliESDVertex(*vertex);
386 fSPDVertex->SetName(fESDListName[kSPDVertex]);
390 void AliESDEvent::SetPrimaryVertex(const AliESDVertex *vertex) {
391 // use already allocated space
393 new(fPrimaryVertex) AliESDVertex(*vertex);
394 fPrimaryVertex->SetName(fESDListName[kPrimaryVertex]);
398 void AliESDEvent::SetFMDData(AliESDFMD * obj) {
399 // use already allocated space
401 new(fESDFMD) AliESDFMD(*obj);
405 void AliESDEvent::SetVZEROData(AliESDVZERO * obj){
406 // use already allocated space
408 new(fESDVZERO) AliESDVZERO(*obj);
411 void AliESDEvent::GetESDfriend(AliESDfriend *ev) const {
413 // Extracts the complementary info from the ESD
417 Int_t ntrk=GetNumberOfTracks();
419 for (Int_t i=0; i<ntrk; i++) {
420 const AliESDtrack *t=GetTrack(i);
421 const AliESDfriendTrack *f=t->GetFriendTrack();
427 void AliESDEvent::AddObject(TObject* obj)
429 // Add an object to the list of object.
430 // Please be aware that in order to increase performance you should
431 // refrain from using TObjArrays (if possible). Use TClonesArrays, instead.
432 fESDObjects->SetOwner(kTRUE);
433 fESDObjects->AddLast(obj);
437 void AliESDEvent::GetStdContent()
439 // set pointers for standard content
440 // get by name much safer and not a big overhead since not called very often
442 fESDRun = (AliESDRun*)fESDObjects->FindObject(fESDListName[kESDRun]);
443 fHeader = (AliESDHeader*)fESDObjects->FindObject(fESDListName[kHeader]);
444 fESDZDC = (AliESDZDC*)fESDObjects->FindObject(fESDListName[kESDZDC]);
445 fESDFMD = (AliESDFMD*)fESDObjects->FindObject(fESDListName[kESDFMD]);
446 fESDVZERO = (AliESDVZERO*)fESDObjects->FindObject(fESDListName[kESDVZERO]);
447 fESDTZERO = (AliESDTZERO*)fESDObjects->FindObject(fESDListName[kESDTZERO]);
448 fSPDVertex = (AliESDVertex*)fESDObjects->FindObject(fESDListName[kSPDVertex]);
449 fPrimaryVertex = (AliESDVertex*)fESDObjects->FindObject(fESDListName[kPrimaryVertex]);
450 fSPDMult = (AliMultiplicity*)fESDObjects->FindObject(fESDListName[kSPDMult]);
451 fPHOSTrigger = (AliESDCaloTrigger*)fESDObjects->FindObject(fESDListName[kPHOSTrigger]);
452 fEMCALTrigger = (AliESDCaloTrigger*)fESDObjects->FindObject(fESDListName[kEMCALTrigger]);
453 fTracks = (TClonesArray*)fESDObjects->FindObject(fESDListName[kTracks]);
454 fMuonTracks = (TClonesArray*)fESDObjects->FindObject(fESDListName[kMuonTracks]);
455 fPmdTracks = (TClonesArray*)fESDObjects->FindObject(fESDListName[kPmdTracks]);
456 fTrdTracks = (TClonesArray*)fESDObjects->FindObject(fESDListName[kTrdTracks]);
457 fV0s = (TClonesArray*)fESDObjects->FindObject(fESDListName[kV0s]);
458 fCascades = (TClonesArray*)fESDObjects->FindObject(fESDListName[kCascades]);
459 fKinks = (TClonesArray*)fESDObjects->FindObject(fESDListName[kKinks]);
460 fCaloClusters = (TClonesArray*)fESDObjects->FindObject(fESDListName[kCaloClusters]);
461 fErrorLogs = (TClonesArray*)fESDObjects->FindObject(fESDListName[kErrorLogs]);
465 void AliESDEvent::SetStdNames(){
466 // Set the names of the standard contents
468 if(fESDObjects->GetEntries()==kESDListN){
469 for(int i = 0;i < fESDObjects->GetEntries();i++){
470 TObject *fObj = fESDObjects->At(i);
471 if(fObj->InheritsFrom("TNamed")){
472 ((TNamed*)fObj)->SetName(fESDListName[i]);
474 else if(fObj->InheritsFrom("TClonesArray")){
475 ((TClonesArray*)fObj)->SetName(fESDListName[i]);
480 printf("%s:%d SetStdNames() Wrong number of Std Entries \n",(char*)__FILE__,__LINE__);
484 void AliESDEvent::CreateStdContent()
486 // create the standard AOD content and set pointers
488 // create standard objects and add them to the TList of objects
489 AddObject(new AliESDRun());
490 AddObject(new AliESDHeader());
491 AddObject(new AliESDZDC());
492 AddObject(new AliESDFMD());
493 AddObject(new AliESDVZERO());
494 AddObject(new AliESDTZERO());
495 AddObject(new AliESDVertex());
496 AddObject(new AliESDVertex());
497 AddObject(new AliMultiplicity());
498 AddObject(new AliESDCaloTrigger());
499 AddObject(new AliESDCaloTrigger());
500 AddObject(new TClonesArray("AliESDtrack",0));
501 AddObject(new TClonesArray("AliESDMuonTrack",0));
502 AddObject(new TClonesArray("AliESDPmdTrack",0));
503 AddObject(new TClonesArray("AliESDTrdTrack",0));
504 AddObject(new TClonesArray("AliESDv0",0));
505 AddObject(new TClonesArray("AliESDcascade",0));
506 AddObject(new TClonesArray("AliESDkink",0));
507 AddObject(new TClonesArray("AliESDCaloCluster",0));
508 AddObject(new TClonesArray("AliRawDataErrorLog",0));
510 // check the order of the indices against enum...
514 // read back pointers
521 TObject* AliESDEvent::FindListObject(const char *name){
522 if(fESDObjects)return fESDObjects->FindObject(name);
526 void AliESDEvent::ReadFromTree(TTree *tree){
529 // if we find the "ESD" branch on the tree we do have the old structure
530 if(tree->GetBranch("ESD")){
531 char ** address = (char **)(tree->GetBranch("ESD")->GetAddress());
533 printf("%s %d AliESDEvent::ReadFromTree() Reading old Tree \n",(char*)__FILE__,__LINE__);
534 tree->SetBranchAddress("ESD",&fESDOld);
536 printf("%s %d AliESDEvent::ReadFromTree() Reading old Tree \n",(char*)__FILE__,__LINE__);
537 printf("%s %d Branch already connected. Using existing branch address. \n",(char*)__FILE__,__LINE__);
538 fESDOld = (AliESD*) (*address);
542 CreateStdContent(); // create for copy
543 // when reading back we are not owner of the list
544 // must not delete it
545 fESDObjects->SetOwner(kFALSE);
552 // Try to find AliESDEvent
553 AliESDEvent *esdEvent = 0;
554 esdEvent = (AliESDEvent*)tree->GetTree()->GetUserInfo()->FindObject("AliESDEvent");
555 //esdEvent = (AliESDEvent*)tree->GetUserInfo()->FindObject("AliESDEvent");
558 // Check if already connected to tree
559 TList* connectedList = (TList*) (tree->GetUserInfo()->FindObject("ESDObjectsConnectedToTree"));
561 // If connected use the connected list if objects
562 fESDObjects->Delete();
563 fESDObjects = connectedList;
568 if(fESDObjects->GetEntries()!=0){
569 // this should not happen here put a warning?
571 // prevent a memory leak when reading back the TList
574 // create a new TList from the UserInfo TList...
575 // copy constructor does not work...
576 fESDObjects = (TList*)(esdEvent->GetList()->Clone());
577 fESDObjects->SetOwner(kFALSE);
578 if(fESDObjects->GetEntries()<kESDListN){
579 printf("%s %d AliESDEvent::ReadFromTree() TList contains less than the standard contents %d < %d \n",
580 (char*)__FILE__,__LINE__,fESDObjects->GetEntries(),kESDListN);
582 // set the branch addresses
583 TIter next(fESDObjects);
585 while((el=(TNamed*)next())){
586 TString bname(el->GetName());
588 if(bname.CompareTo("AliESDfriend")==0)
590 // AliESDfriend does not have a name ...
591 printf("Setting AlieSDFrien \n");
592 tree->SetBranchAddress("ESDfriend.",fESDObjects->GetObjectRef(el));
595 tree->SetBranchAddress(bname.Data(),fESDObjects->GetObjectRef(el));
599 // when reading back we are not owner of the list
600 // must not delete it
601 fESDObjects->SetOwner(kFALSE);
602 fESDObjects->SetName("ESDObjectsConnectedToTree");
603 // we are not owner of the list objects
604 // must not delete it
605 tree->GetUserInfo()->Add(fESDObjects);
609 // we can't get the list from the user data, create standard content
610 // and set it by hand (no ESDfriend at the moment
612 TIter next(fESDObjects);
614 while((el=(TNamed*)next())){
615 TString bname(el->GetName());
616 tree->SetBranchAddress(bname.Data(),fESDObjects->GetObjectRef(el));
619 // when reading back we are not owner of the list
620 // must not delete it
621 fESDObjects->SetOwner(kFALSE);
629 void AliESDEvent::CopyFromOldESD()
631 // Method which copies over everthing from the old esd structure to the
637 SetRunNumber(fESDOld->GetRunNumber());
638 SetPeriodNumber(fESDOld->GetPeriodNumber());
639 SetMagneticField(fESDRun->GetMagneticField());
641 // leave out diamond ...
642 // SetDiamond(const AliESDVertex *vertex) { fESDRun->SetDiamond(vertex);}
645 SetTriggerMask(fESDOld->GetTriggerMask());
646 SetOrbitNumber(fESDOld->GetOrbitNumber());
647 SetTimeStamp(fESDOld->GetTimeStamp());
648 SetEventType(fESDOld->GetEventType());
649 SetEventNumberInFile(fESDOld->GetEventNumberInFile());
650 SetBunchCrossNumber(fESDOld->GetBunchCrossNumber());
651 SetTriggerCluster(fESDOld->GetTriggerCluster());
655 SetZDC(fESDOld->GetZDCN1Energy(),
656 fESDOld->GetZDCP1Energy(),
657 fESDOld->GetZDCEMEnergy(),
658 fESDOld->GetZDCN2Energy(),
659 fESDOld->GetZDCP2Energy(),
660 fESDOld->GetZDCParticipants());
664 SetFMDData(fESDOld->GetFMDData());
668 SetT0zVertex(fESDOld->GetT0zVertex());
669 SetT0(fESDOld->GetT0());
673 SetVZEROData(fESDOld->GetVZEROData());
675 SetVertex(fESDOld->GetVertex());
677 SetPrimaryVertex(fESDOld->GetPrimaryVertex());
679 SetMultiplicity(fESDOld->GetMultiplicity());
681 for(int i = 0;i<fESDOld->GetNumberOfTracks();i++){
682 AddTrack(fESDOld->GetTrack(i));
685 for(int i = 0;i<fESDOld->GetNumberOfMuonTracks();i++){
686 AddMuonTrack(fESDOld->GetMuonTrack(i));
689 for(int i = 0;i<fESDOld->GetNumberOfPmdTracks();i++){
690 AddPmdTrack(fESDOld->GetPmdTrack(i));
693 for(int i = 0;i<fESDOld->GetNumberOfTrdTracks();i++){
694 AddTrdTrack(fESDOld->GetTrdTrack(i));
697 for(int i = 0;i<fESDOld->GetNumberOfV0s();i++){
698 AddV0(fESDOld->GetV0(i));
701 for(int i = 0;i<fESDOld->GetNumberOfCascades();i++){
702 AddCascade(fESDOld->GetCascade(i));
705 for(int i = 0;i<fESDOld->GetNumberOfKinks();i++){
706 AddKink(fESDOld->GetKink(i));
710 for(int i = 0;i<fESDOld->GetNumberOfCaloClusters();i++){
711 AddCaloCluster(fESDOld->GetCaloCluster(i));