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 physics analysis of data.
21 // It also ensures the backward compatibility with the old ESD format.
23 AliESDEvent *ev= new AliESDEvent();
24 ev->ReadFromTree(esdTree);
26 for (Int_t i=0; i<nev; i++) {
28 if(ev->GetAliESDOld())ev->CopyFromOldESD();
30 // The AliESDInputHandler does this automatically for you
32 // Origin: Christian Klein-Boesing, CERN, Christian.Klein-Boesing@cern.ch
33 //-----------------------------------------------------------------
36 #include "TRefArray.h"
39 #include <TInterpreter.h>
41 #include "AliESDEvent.h"
42 #include "AliESDfriend.h"
43 #include "AliESDVZERO.h"
44 #include "AliESDFMD.h"
46 #include "AliESDMuonTrack.h"
47 #include "AliESDMuonCluster.h"
48 #include "AliESDMuonPad.h"
49 #include "AliESDPmdTrack.h"
50 #include "AliESDTrdTrack.h"
51 #include "AliESDVertex.h"
52 #include "AliESDcascade.h"
53 #include "AliESDPmdTrack.h"
54 #include "AliESDTrdTrigger.h"
55 #include "AliESDTrdTrack.h"
56 #include "AliESDTrdTracklet.h"
57 #include "AliESDVertex.h"
58 #include "AliVertexerTracks.h"
59 #include "AliESDcascade.h"
60 #include "AliESDkink.h"
61 #include "AliESDtrack.h"
62 #include "AliESDHLTtrack.h"
63 #include "AliESDCaloCluster.h"
64 #include "AliESDCaloCells.h"
66 #include "AliESDFMD.h"
67 #include "AliESDVZERO.h"
68 #include "AliMultiplicity.h"
69 #include "AliRawDataErrorLog.h"
71 #include "AliESDACORDE.h"
72 #include "AliESDHLTDecision.h"
73 #include "AliCentrality.h"
74 #include "AliESDCosmicTrack.h"
76 #include "AliESDMFT.h"
78 #include "AliEventplane.h"
85 // here we define the names, some classes are no TNamed, therefore the classnames
87 const char* AliESDEvent::fgkESDListName[kESDListN] = {"AliESDRun",
115 "AliRawDataErrorLogs",
124 //______________________________________________________________________________
125 AliESDEvent::AliESDEvent():
127 fESDObjects(new TList()),
142 fSPDPileupVertices(0),
143 fTrkPileupVertices(0),
155 fEMCALCells(0), fPHOSCells(0),
158 fOldMuonStructure(kFALSE),
166 fDetectorStatus(0xFFFFFFFF)
172 //______________________________________________________________________________
173 AliESDEvent::AliESDEvent(const AliESDEvent& esd):
175 fESDObjects(new TList()),
176 fESDRun(new AliESDRun(*esd.fESDRun)),
177 fHeader(new AliESDHeader(*esd.fHeader)),
178 fESDZDC(new AliESDZDC(*esd.fESDZDC)),
179 fESDFMD(new AliESDFMD(*esd.fESDFMD)),
180 fESDVZERO(new AliESDVZERO(*esd.fESDVZERO)),
181 fESDTZERO(new AliESDTZERO(*esd.fESDTZERO)),
182 fTPCVertex(new AliESDVertex(*esd.fTPCVertex)),
183 fSPDVertex(new AliESDVertex(*esd.fSPDVertex)),
184 fPrimaryVertex(new AliESDVertex(*esd.fPrimaryVertex)),
185 fSPDMult(new AliMultiplicity(*esd.fSPDMult)),
186 fPHOSTrigger(new AliESDCaloTrigger(*esd.fPHOSTrigger)),
187 fEMCALTrigger(new AliESDCaloTrigger(*esd.fEMCALTrigger)),
188 fESDACORDE(new AliESDACORDE(*esd.fESDACORDE)),
189 fTrdTrigger(new AliESDTrdTrigger(*esd.fTrdTrigger)),
190 fSPDPileupVertices(new TClonesArray(*esd.fSPDPileupVertices)),
191 fTrkPileupVertices(new TClonesArray(*esd.fTrkPileupVertices)),
192 fTracks(new TClonesArray(*esd.fTracks)),
193 fMuonTracks(new TClonesArray(*esd.fMuonTracks)),
194 fMuonClusters(new TClonesArray(*esd.fMuonClusters)),
195 fMuonPads(new TClonesArray(*esd.fMuonPads)),
196 fPmdTracks(new TClonesArray(*esd.fPmdTracks)),
197 fTrdTracks(new TClonesArray(*esd.fTrdTracks)),
198 fTrdTracklets(new TClonesArray(*esd.fTrdTracklets)),
199 fV0s(new TClonesArray(*esd.fV0s)),
200 fCascades(new TClonesArray(*esd.fCascades)),
201 fKinks(new TClonesArray(*esd.fKinks)),
202 fCaloClusters(new TClonesArray(*esd.fCaloClusters)),
203 fEMCALCells(new AliESDCaloCells(*esd.fEMCALCells)),
204 fPHOSCells(new AliESDCaloCells(*esd.fPHOSCells)),
205 fCosmicTracks(new TClonesArray(*esd.fCosmicTracks)),
206 fErrorLogs(new TClonesArray(*esd.fErrorLogs)),
207 fOldMuonStructure(esd.fOldMuonStructure),
208 fESDOld(esd.fESDOld ? new AliESD(*esd.fESDOld) : 0),
209 fESDFriendOld(esd.fESDFriendOld ? new AliESDfriend(*esd.fESDFriendOld) : 0),
210 fConnected(esd.fConnected),
211 fUseOwnList(esd.fUseOwnList),
212 fTOFHeader(new AliTOFHeader(*esd.fTOFHeader)),
213 fCentrality(new AliCentrality(*esd.fCentrality)),
214 fEventplane(new AliEventplane(*esd.fEventplane)),
215 fDetectorStatus(esd.fDetectorStatus)
217 // , fESDMFT(new AliESDMFT(*esd.fESDMFT))
222 printf("copying ESD event...\n"); // AU
223 // CKB init in the constructor list and only add here ...
228 AddObject(fESDVZERO);
229 AddObject(fESDTZERO);
230 AddObject(fTPCVertex);
231 AddObject(fSPDVertex);
232 AddObject(fPrimaryVertex);
234 AddObject(fPHOSTrigger);
235 AddObject(fEMCALTrigger);
236 AddObject(fTrdTrigger);
237 AddObject(fSPDPileupVertices);
238 AddObject(fTrkPileupVertices);
240 AddObject(fMuonTracks);
241 AddObject(fPmdTracks);
242 AddObject(fTrdTracks);
243 AddObject(fTrdTracklets);
245 AddObject(fCascades);
247 AddObject(fCaloClusters);
248 AddObject(fEMCALCells);
249 AddObject(fPHOSCells);
250 AddObject(fCosmicTracks);
251 AddObject(fErrorLogs);
252 AddObject(fESDACORDE);
253 AddObject(fTOFHeader);
254 AddObject(fMuonClusters);
255 AddObject(fMuonPads);
257 // AddObject(fESDMFT);
263 //______________________________________________________________________________
264 AliESDEvent & AliESDEvent::operator=(const AliESDEvent& source) {
266 // Assignment operator
268 if(&source == this) return *this;
269 AliVEvent::operator=(source);
271 // This assumes that the list is already created
272 // and that the virtual void Copy(Tobject&) function
273 // is correctly implemented in the derived class
274 // otherwise only TObject::Copy() will be used
278 if((fESDObjects->GetSize()==0)&&(source.fESDObjects->GetSize()>=kESDListN)){
279 // We cover the case that we do not yet have the
280 // standard content but the source has it
284 TIter next(source.GetList());
287 while ((its = next())) {
288 name.Form("%s", its->GetName());
289 TObject *mine = fESDObjects->FindObject(name.Data());
291 TClass* pClass=TClass::GetClass(its->ClassName());
293 AliWarning(Form("Can not find class description for entry %s (%s)\n",
294 its->ClassName(), name.Data()));
298 mine=(TObject*)pClass->New();
300 // not in this: can be added to list
301 AliWarning(Form("%s:%d Could not find %s for copying \n",
302 (char*)__FILE__,__LINE__,name.Data()));
305 if(mine->InheritsFrom("TNamed")){
306 ((TNamed*)mine)->SetName(name);
308 else if(mine->InheritsFrom("TCollection")){
309 if(mine->InheritsFrom("TClonesArray")) {
310 TClonesArray* tcits = dynamic_cast<TClonesArray*>(its);
312 dynamic_cast<TClonesArray*>(mine)->SetClass(tcits->GetClass());
314 dynamic_cast<TCollection*>(mine)->SetName(name);
316 AliDebug(1, Form("adding object %s of type %s", mine->GetName(), mine->ClassName()));
320 if(!its->InheritsFrom("TCollection")){
324 else if(its->InheritsFrom("TClonesArray")){
325 // Create or expand the tclonesarray pointers
326 // so we can directly copy to the object
327 TClonesArray *itstca = (TClonesArray*)its;
328 TClonesArray *minetca = (TClonesArray*)mine;
330 // this leaves the capacity of the TClonesArray the same
331 // except for a factor of 2 increase when size > capacity
332 // does not release any memory occupied by the tca
333 minetca->ExpandCreate(itstca->GetEntriesFast());
334 for(int i = 0;i < itstca->GetEntriesFast();++i){
336 TObject *minetcaobj = minetca->At(i);
337 TObject *itstcaobj = itstca->At(i);
338 // no need to delete first
339 // pointers within the class should be handled by Copy()...
340 // Can there be Empty slots?
341 itstcaobj->Copy(*minetcaobj);
345 AliWarning(Form("%s:%d cannot copy TCollection \n",
346 (char*)__FILE__,__LINE__));
350 fOldMuonStructure = source.fOldMuonStructure;
352 fCentrality = source.fCentrality;
353 fEventplane = source.fEventplane;
355 fConnected = source.fConnected;
356 fUseOwnList = source.fUseOwnList;
358 fDetectorStatus = source.fDetectorStatus;
364 //______________________________________________________________________________
365 AliESDEvent::~AliESDEvent()
368 // Standard destructor
371 // everthing on the list gets deleted automatically
374 if(fESDObjects&&!fConnected)
379 if (fCentrality) delete fCentrality;
380 if (fEventplane) delete fEventplane;
384 void AliESDEvent::Copy(TObject &obj) const {
386 // interface to TOBject::Copy
387 // Copies the content of this into obj!
388 // bascially obj = *this
390 if(this==&obj)return;
391 AliESDEvent *robj = dynamic_cast<AliESDEvent*>(&obj);
392 if(!robj)return; // not an AliESEvent
397 //______________________________________________________________________________
398 void AliESDEvent::Reset()
402 // Std content + Non std content
404 // Reset the standard contents
407 // reset for the old data without AliESDEvent...
408 if(fESDOld)fESDOld->Reset();
410 fESDFriendOld->~AliESDfriend();
411 new (fESDFriendOld) AliESDfriend();
415 if(fESDObjects->GetSize()>kESDListN){
416 // we have non std content
417 // this also covers esdfriends
418 for(int i = kESDListN;i < fESDObjects->GetSize();++i){
419 TObject *pObject = fESDObjects->At(i);
421 if(pObject->InheritsFrom(TClonesArray::Class())){
422 ((TClonesArray*)pObject)->Delete();
424 else if(!pObject->InheritsFrom(TCollection::Class())){
425 TClass *pClass = TClass::GetClass(pObject->ClassName());
426 if (pClass && pClass->GetListOfMethods()->FindObject("Clear")) {
427 AliDebug(1, Form("Clear for object %s class %s", pObject->GetName(), pObject->ClassName()));
431 AliDebug(1, Form("ResetWithPlacementNew for object %s class %s", pObject->GetName(), pObject->ClassName()));
432 ResetWithPlacementNew(pObject);
436 AliWarning(Form("No reset for %s \n",
437 pObject->ClassName()));
444 Bool_t AliESDEvent::ResetWithPlacementNew(TObject *pObject){
446 // funtion to reset using the already allocated space
448 Long_t dtoronly = TObject::GetDtorOnly();
449 TClass *pClass = TClass::GetClass(pObject->ClassName());
450 TObject::SetDtorOnly(pObject);
452 // Recreate with placement new
453 pClass->New(pObject);
454 // Restore the state.
455 TObject::SetDtorOnly((void*)dtoronly);
459 void AliESDEvent::ResetStdContent()
461 // Reset the standard contents
462 if(fESDRun) fESDRun->Reset();
463 if(fHeader) fHeader->Reset();
464 if(fCentrality) fCentrality->Reset();
465 if(fEventplane) fEventplane->Reset();
466 if(fESDZDC) fESDZDC->Reset();
471 // reset by callin d'to /c'tor keep the pointer
472 fESDVZERO->~AliESDVZERO();
473 new (fESDVZERO) AliESDVZERO();
476 fESDACORDE->~AliESDACORDE();
477 new (fESDACORDE) AliESDACORDE();
479 if(fESDTZERO) fESDTZERO->Reset();
480 // CKB no clear/reset implemented
482 fTPCVertex->~AliESDVertex();
483 new (fTPCVertex) AliESDVertex();
484 fTPCVertex->SetName(fgkESDListName[kTPCVertex]);
487 fSPDVertex->~AliESDVertex();
488 new (fSPDVertex) AliESDVertex();
489 fSPDVertex->SetName(fgkESDListName[kSPDVertex]);
492 fPrimaryVertex->~AliESDVertex();
493 new (fPrimaryVertex) AliESDVertex();
494 fPrimaryVertex->SetName(fgkESDListName[kPrimaryVertex]);
497 fSPDMult->~AliMultiplicity();
498 new (fSPDMult) AliMultiplicity();
501 fTOFHeader->~AliTOFHeader();
502 new (fTOFHeader) AliTOFHeader();
503 //fTOFHeader->SetName(fgkESDListName[kTOFHeader]);
506 fTrdTrigger->~AliESDTrdTrigger();
507 new (fTrdTrigger) AliESDTrdTrigger();
511 // fESDMFT->~AliESDMFT();
512 // new (fESDMFT) AliESDMFT();
516 if(fPHOSTrigger)fPHOSTrigger->DeAllocate();
517 if(fEMCALTrigger)fEMCALTrigger->DeAllocate();
518 if(fSPDPileupVertices)fSPDPileupVertices->Delete();
519 if(fTrkPileupVertices)fTrkPileupVertices->Delete();
520 if(fTracks)fTracks->Delete();
521 if(fMuonTracks)fMuonTracks->Clear("C");
522 if(fMuonClusters)fMuonClusters->Clear("C");
523 if(fMuonPads)fMuonPads->Clear("C");
524 if(fPmdTracks)fPmdTracks->Delete();
525 if(fTrdTracks)fTrdTracks->Delete();
526 if(fTrdTracklets)fTrdTracklets->Delete();
527 if(fV0s)fV0s->Delete();
528 if(fCascades)fCascades->Delete();
529 if(fKinks)fKinks->Delete();
530 if(fCaloClusters)fCaloClusters->Delete();
531 if(fPHOSCells)fPHOSCells->DeleteContainer();
532 if(fEMCALCells)fEMCALCells->DeleteContainer();
533 if(fCosmicTracks)fCosmicTracks->Delete();
534 if(fErrorLogs) fErrorLogs->Delete();
536 // don't reset fconnected fConnected and the list
541 Int_t AliESDEvent::AddV0(const AliESDv0 *v) {
545 TClonesArray &fv = *fV0s;
546 Int_t idx=fV0s->GetEntriesFast();
547 new(fv[idx]) AliESDv0(*v);
551 //______________________________________________________________________________
552 void AliESDEvent::Print(Option_t *) const
555 // Print header information of the event
557 printf("ESD run information\n");
558 printf("Event # in file %d Bunch crossing # %d Orbit # %d Period # %d Run # %d Trigger %lld Magnetic field %f \n",
559 GetEventNumberInFile(),
560 GetBunchCrossNumber(),
565 GetMagneticField() );
567 printf("Vertex: (%.4f +- %.4f, %.4f +- %.4f, %.4f +- %.4f) cm\n",
568 fPrimaryVertex->GetXv(), fPrimaryVertex->GetXRes(),
569 fPrimaryVertex->GetYv(), fPrimaryVertex->GetYRes(),
570 fPrimaryVertex->GetZv(), fPrimaryVertex->GetZRes());
571 printf("Mean vertex in RUN: X=%.4f Y=%.4f Z=%.4f cm\n",
572 GetDiamondX(),GetDiamondY(),GetDiamondZ());
574 printf("SPD Multiplicity. Number of tracklets %d \n",
575 fSPDMult->GetNumberOfTracklets());
576 printf("Number of pileup primary vertices reconstructed with SPD %d\n",
577 GetNumberOfPileupVerticesSPD());
578 printf("Number of pileup primary vertices reconstructed using the tracks %d\n",
579 GetNumberOfPileupVerticesTracks());
580 printf("Number of tracks: \n");
581 printf(" charged %d\n", GetNumberOfTracks());
582 printf(" muon %d\n", GetNumberOfMuonTracks());
583 printf(" pmd %d\n", GetNumberOfPmdTracks());
584 printf(" trd %d\n", GetNumberOfTrdTracks());
585 printf(" trd trkl %d\n", GetNumberOfTrdTracklets());
586 printf(" v0 %d\n", GetNumberOfV0s());
587 printf(" cascades %d\n", GetNumberOfCascades());
588 printf(" kinks %d\n", GetNumberOfKinks());
589 if(fPHOSCells)printf(" PHOSCells %d\n", fPHOSCells->GetNumberOfCells());
590 else printf(" PHOSCells not in the Event\n");
591 if(fEMCALCells)printf(" EMCALCells %d\n", fEMCALCells->GetNumberOfCells());
592 else printf(" EMCALCells not in the Event\n");
593 printf(" CaloClusters %d\n", GetNumberOfCaloClusters());
594 printf(" FMD %s\n", (fESDFMD ? "yes" : "no"));
595 printf(" VZERO %s\n", (fESDVZERO ? "yes" : "no"));
596 printf(" muClusters %d\n", fMuonClusters ? fMuonClusters->GetEntriesFast() : 0);
597 printf(" muPad %d\n", fMuonPads ? fMuonPads->GetEntriesFast() : 0);
598 if (fCosmicTracks) printf(" Cosmics %d\n", GetNumberOfCosmicTracks());
600 //printf(" MFT %s\n", (fESDMFT ? "yes" : "no"));
604 TObject* pHLTDecision=GetHLTTriggerDecision();
605 printf("HLT trigger decision: %s\n", pHLTDecision?pHLTDecision->GetOption():"not available");
606 if (pHLTDecision) pHLTDecision->Print("compact");
611 void AliESDEvent::SetESDfriend(const AliESDfriend *ev) const {
613 // Attaches the complementary info to the ESD
617 // to be sure that we set the tracks also
618 // in case of old esds
619 // if(fESDOld)CopyFromOldESD();
621 Int_t ntrk=ev->GetNumberOfTracks();
623 for (Int_t i=0; i<ntrk; i++) {
624 const AliESDfriendTrack *f=ev->GetTrack(i);
625 if (!f) {AliFatal(Form("NULL pointer for ESD track %d",i));}
626 GetTrack(i)->SetFriendTrack(f);
630 Bool_t AliESDEvent::RemoveKink(Int_t rm) const {
631 // ---------------------------------------------------------
632 // Remove a kink candidate and references to it from ESD,
633 // if this candidate does not come from a reconstructed decay
634 // Not yet implemented...
635 // ---------------------------------------------------------
636 Int_t last=GetNumberOfKinks()-1;
637 if ((rm<0)||(rm>last)) return kFALSE;
642 Bool_t AliESDEvent::RemoveV0(Int_t rm) const {
643 // ---------------------------------------------------------
644 // Remove a V0 candidate and references to it from ESD,
645 // if this candidate does not come from a reconstructed decay
646 // ---------------------------------------------------------
647 Int_t last=GetNumberOfV0s()-1;
648 if ((rm<0)||(rm>last)) return kFALSE;
650 AliESDv0 *v0=GetV0(rm);
651 Int_t idxP=v0->GetPindex(), idxN=v0->GetNindex();
654 Int_t lastIdxP=v0->GetPindex(), lastIdxN=v0->GetNindex();
658 // Check if this V0 comes from a reconstructed decay
659 Int_t ncs=GetNumberOfCascades();
660 for (Int_t n=0; n<ncs; n++) {
661 AliESDcascade *cs=GetCascade(n);
663 Int_t csIdxP=cs->GetPindex();
664 Int_t csIdxN=cs->GetNindex();
667 if (idxN==csIdxN) return kFALSE;
669 if (csIdxP==lastIdxP)
670 if (csIdxN==lastIdxN) used++;
673 //Replace the removed V0 with the last V0
674 TClonesArray &a=*fV0s;
675 delete a.RemoveAt(rm);
677 if (rm==last) return kTRUE;
679 //v0 is pointing to the last V0 candidate...
680 new (a[rm]) AliESDv0(*v0);
681 delete a.RemoveAt(last);
683 if (!used) return kTRUE;
686 // Remap the indices of the daughters of reconstructed decays
687 for (Int_t n=0; n<ncs; n++) {
688 AliESDcascade *cs=GetCascade(n);
691 Int_t csIdxP=cs->GetPindex();
692 Int_t csIdxN=cs->GetNindex();
694 if (csIdxP==lastIdxP)
695 if (csIdxN==lastIdxN) {
696 cs->AliESDv0::SetIndex(1,idxP);
697 cs->AliESDv0::SetIndex(0,idxN);
699 if (!used) return kTRUE;
706 Bool_t AliESDEvent::RemoveTrack(Int_t rm) const {
707 // ---------------------------------------------------------
708 // Remove a track and references to it from ESD,
709 // if this track does not come from a reconstructed decay
710 // ---------------------------------------------------------
711 Int_t last=GetNumberOfTracks()-1;
712 if ((rm<0)||(rm>last)) return kFALSE;
716 // Check if this track comes from the reconstructed primary vertices
717 if (fTPCVertex && fTPCVertex->GetStatus()) {
718 UShort_t *primIdx=fTPCVertex->GetIndices();
719 Int_t n=fTPCVertex->GetNIndices();
721 Int_t idx=Int_t(primIdx[n]);
722 if (rm==idx) return kFALSE;
723 if (idx==last) used++;
726 if (fPrimaryVertex && fPrimaryVertex->GetStatus()) {
727 UShort_t *primIdx=fPrimaryVertex->GetIndices();
728 Int_t n=fPrimaryVertex->GetNIndices();
730 Int_t idx=Int_t(primIdx[n]);
731 if (rm==idx) return kFALSE;
732 if (idx==last) used++;
736 // Check if this track comes from a reconstructed decay
737 Int_t nv0=GetNumberOfV0s();
738 for (Int_t n=0; n<nv0; n++) {
739 AliESDv0 *v0=GetV0(n);
741 Int_t idx=v0->GetNindex();
742 if (rm==idx) return kFALSE;
743 if (idx==last) used++;
746 if (rm==idx) return kFALSE;
747 if (idx==last) used++;
750 Int_t ncs=GetNumberOfCascades();
751 for (Int_t n=0; n<ncs; n++) {
752 AliESDcascade *cs=GetCascade(n);
754 Int_t idx=cs->GetIndex();
755 if (rm==idx) return kFALSE;
756 if (idx==last) used++;
760 if (rm==idx) return kFALSE;
761 if (idx==last) used++;
764 if (rm==idx) return kFALSE;
765 if (idx==last) used++;
768 Int_t nkn=GetNumberOfKinks();
769 for (Int_t n=0; n<nkn; n++) {
770 AliESDkink *kn=GetKink(n);
772 Int_t idx=kn->GetIndex(0);
773 if (rm==idx) return kFALSE;
774 if (idx==last) used++;
777 if (rm==idx) return kFALSE;
778 if (idx==last) used++;
781 // Check if this track is associated with a CaloCluster
782 Int_t ncl=GetNumberOfCaloClusters();
783 for (Int_t n=0; n<ncl; n++) {
784 AliESDCaloCluster *cluster=GetCaloCluster(n);
785 TArrayI *arr=cluster->GetTracksMatched();
786 Int_t s=arr->GetSize();
788 Int_t idx=arr->At(s);
789 if (rm==idx) return kFALSE;
790 if (idx==last) used++;
796 //Replace the removed track with the last track
797 TClonesArray &a=*fTracks;
798 delete a.RemoveAt(rm);
800 if (rm==last) return kTRUE;
802 AliESDtrack *t=GetTrack(last);
803 if (!t) {AliFatal(Form("NULL pointer for ESD track %d",last));}
805 new (a[rm]) AliESDtrack(*t);
806 delete a.RemoveAt(last);
809 if (!used) return kTRUE;
812 // Remap the indices of the tracks used for the primary vertex reconstruction
813 if (fTPCVertex && fTPCVertex->GetStatus()) {
814 UShort_t *primIdx=fTPCVertex->GetIndices();
815 Int_t n=fTPCVertex->GetNIndices();
817 Int_t idx=Int_t(primIdx[n]);
819 primIdx[n]=Short_t(rm);
821 if (!used) return kTRUE;
825 if (fPrimaryVertex && fPrimaryVertex->GetStatus()) {
826 UShort_t *primIdx=fPrimaryVertex->GetIndices();
827 Int_t n=fPrimaryVertex->GetNIndices();
829 Int_t idx=Int_t(primIdx[n]);
831 primIdx[n]=Short_t(rm);
833 if (!used) return kTRUE;
838 // Remap the indices of the daughters of reconstructed decays
839 for (Int_t n=0; n<nv0; n++) {
840 AliESDv0 *v0=GetV0(n);
841 if (v0->GetIndex(0)==last) {
844 if (!used) return kTRUE;
846 if (v0->GetIndex(1)==last) {
849 if (!used) return kTRUE;
853 for (Int_t n=0; n<ncs; n++) {
854 AliESDcascade *cs=GetCascade(n);
855 if (cs->GetIndex()==last) {
858 if (!used) return kTRUE;
861 if (v0->GetIndex(0)==last) {
864 if (!used) return kTRUE;
866 if (v0->GetIndex(1)==last) {
869 if (!used) return kTRUE;
873 for (Int_t n=0; n<nkn; n++) {
874 AliESDkink *kn=GetKink(n);
875 if (kn->GetIndex(0)==last) {
878 if (!used) return kTRUE;
880 if (kn->GetIndex(1)==last) {
883 if (!used) return kTRUE;
887 // Remap the indices of the tracks accosicated with CaloClusters
888 for (Int_t n=0; n<ncl; n++) {
889 AliESDCaloCluster *cluster=GetCaloCluster(n);
890 TArrayI *arr=cluster->GetTracksMatched();
891 Int_t s=arr->GetSize();
893 Int_t idx=arr->At(s);
897 if (!used) return kTRUE;
906 Bool_t AliESDEvent::Clean(Float_t *cleanPars) {
908 // Remove the data which are not needed for the physics analysis.
910 // 1) Cleaning the V0 candidates
911 // ---------------------------
912 // If the cosine of the V0 pointing angle "csp" and
913 // the DCA between the daughter tracks "dca" does not satisfy
916 // csp > cleanPars[1] + dca/cleanPars[0]*(1.- cleanPars[1])
918 // an attempt to remove this V0 candidate from ESD is made.
920 // The V0 candidate gets removed if it does not belong to any
921 // recosntructed cascade decay
923 // 12.11.2007, optimal values: cleanPars[0]=0.5, cleanPars[1]=0.999
925 // 2) Cleaning the tracks
926 // ----------------------
927 // If track's transverse parameter is larger than cleanPars[2]
929 // track's longitudinal parameter is larger than cleanPars[3]
930 // an attempt to remove this track from ESD is made.
932 // The track gets removed if it does not come
933 // from a reconstructed decay
937 Float_t dcaMax=cleanPars[0];
938 Float_t cspMin=cleanPars[1];
940 Int_t nV0s=GetNumberOfV0s();
941 for (Int_t i=nV0s-1; i>=0; i--) {
942 AliESDv0 *v0=GetV0(i);
944 Float_t dca=v0->GetDcaV0Daughters();
945 Float_t csp=v0->GetV0CosineOfPointingAngle();
946 Float_t cspcut=cspMin + dca/dcaMax*(1.-cspMin);
947 if (csp > cspcut) continue;
948 if (RemoveV0(i)) rc=kTRUE;
952 Float_t dmax=cleanPars[2], zmax=cleanPars[3];
954 const AliESDVertex *vertex=GetPrimaryVertexSPD();
955 Bool_t vtxOK=vertex->GetStatus();
957 Int_t nTracks=GetNumberOfTracks();
958 for (Int_t i=nTracks-1; i>=0; i--) {
959 AliESDtrack *track=GetTrack(i);
960 if (!track) {AliFatal(Form("NULL pointer for ESD track %d",i));}
961 Float_t xy,z; track->GetImpactParameters(xy,z);
962 if ((TMath::Abs(xy) > dmax) || (vtxOK && (TMath::Abs(z) > zmax))) {
963 if (RemoveTrack(i)) rc=kTRUE;
970 Char_t AliESDEvent::AddPileupVertexSPD(const AliESDVertex *vtx)
972 // Add a pileup primary vertex reconstructed with SPD
973 TClonesArray &ftr = *fSPDPileupVertices;
974 Char_t n=Char_t(ftr.GetEntriesFast());
975 AliESDVertex *vertex = new(ftr[n]) AliESDVertex(*vtx);
980 Char_t AliESDEvent::AddPileupVertexTracks(const AliESDVertex *vtx)
982 // Add a pileup primary vertex reconstructed with SPD
983 TClonesArray &ftr = *fTrkPileupVertices;
984 Char_t n=Char_t(ftr.GetEntriesFast());
985 AliESDVertex *vertex = new(ftr[n]) AliESDVertex(*vtx);
990 Int_t AliESDEvent::AddTrack(const AliESDtrack *t)
993 TClonesArray &ftr = *fTracks;
994 AliESDtrack * track = new(ftr[fTracks->GetEntriesFast()])AliESDtrack(*t);
995 track->SetID(fTracks->GetEntriesFast()-1);
996 return track->GetID();
999 AliESDtrack* AliESDEvent::NewTrack()
1002 TClonesArray &ftr = *fTracks;
1003 AliESDtrack * track = new(ftr[fTracks->GetEntriesFast()])AliESDtrack();
1004 track->SetID(fTracks->GetEntriesFast()-1);
1008 //______________________________________________________________________________
1009 Bool_t AliESDEvent::MoveMuonObjects()
1011 // move MUON clusters and pads to the new ESD structure in needed.
1012 // to ensure backward compatibility
1014 if (!fOldMuonStructure) return kTRUE;
1016 if (!fMuonTracks || !fMuonClusters || !fMuonPads) return kFALSE;
1018 Bool_t reset = kTRUE;
1019 Bool_t containTrackerData = kFALSE;
1020 for (Int_t i = 0; i < fMuonTracks->GetEntriesFast(); i++) {
1022 AliESDMuonTrack *track = (AliESDMuonTrack*) fMuonTracks->UncheckedAt(i);
1024 if (track->ContainTrackerData()) containTrackerData = kTRUE;
1027 if (!track->IsOldTrack()) continue;
1029 // remove objects connected to previous event if needed
1031 if (fMuonClusters->GetEntriesFast() > 0) fMuonClusters->Clear("C");
1032 if (fMuonPads->GetEntriesFast() > 0) fMuonPads->Clear("C");
1036 track->MoveClustersToESD(*this);
1040 // remove objects connected to previous event if needed
1041 if (!containTrackerData) {
1042 if (fMuonClusters->GetEntriesFast() > 0) fMuonClusters->Clear("C");
1043 if (fMuonPads->GetEntriesFast() > 0) fMuonPads->Clear("C");
1049 //______________________________________________________________________________
1050 AliESDMuonTrack* AliESDEvent::GetMuonTrack(Int_t i)
1052 // get the MUON track at the position i in the internal array of track
1053 if (!fMuonTracks) return 0x0;
1054 if (!MoveMuonObjects()) return 0x0;
1055 AliESDMuonTrack *track = (AliESDMuonTrack*) fMuonTracks->UncheckedAt(i);
1056 track->SetESDEvent(this);
1060 //______________________________________________________________________________
1061 void AliESDEvent::AddMuonTrack(const AliESDMuonTrack *t)
1064 TClonesArray &fmu = *fMuonTracks;
1065 AliESDMuonTrack *track = new(fmu[fMuonTracks->GetEntriesFast()]) AliESDMuonTrack(*t);
1066 track->MoveClustersToESD(*this);
1069 //______________________________________________________________________________
1070 AliESDMuonTrack* AliESDEvent::NewMuonTrack()
1072 // create a new MUON track at the end of the internal array of track
1073 TClonesArray &fmu = *fMuonTracks;
1074 return new(fmu[fMuonTracks->GetEntriesFast()]) AliESDMuonTrack();
1077 //______________________________________________________________________________
1078 Int_t AliESDEvent::GetNumberOfMuonClusters()
1080 // get the number of MUON clusters
1081 if (!fMuonClusters) return 0;
1082 if (!MoveMuonObjects()) return 0;
1083 return fMuonClusters->GetEntriesFast();
1086 //______________________________________________________________________________
1087 AliESDMuonCluster* AliESDEvent::GetMuonCluster(Int_t i)
1089 // get the MUON cluster at the position i in the internal array of cluster
1090 if (!fMuonClusters) return 0x0;
1091 if (!MoveMuonObjects()) return 0x0;
1092 return (AliESDMuonCluster*) fMuonClusters->UncheckedAt(i);
1095 //______________________________________________________________________________
1096 AliESDMuonCluster* AliESDEvent::FindMuonCluster(UInt_t clusterId)
1098 // find the MUON cluster with this Id in the internal array of cluster
1099 if (!fMuonClusters) return 0x0;
1100 if (!MoveMuonObjects()) return 0x0;
1101 for (Int_t i = 0; i < fMuonClusters->GetEntriesFast(); i++) {
1102 AliESDMuonCluster *cluster = (AliESDMuonCluster*) fMuonClusters->UncheckedAt(i);
1103 if (cluster->GetUniqueID() == clusterId) return cluster;
1108 //______________________________________________________________________________
1109 AliESDMuonCluster* AliESDEvent::NewMuonCluster()
1111 // create a new MUON cluster at the end of the internal array of cluster
1112 TClonesArray &fmu = *fMuonClusters;
1113 return new(fmu[fMuonClusters->GetEntriesFast()]) AliESDMuonCluster();
1116 //______________________________________________________________________________
1117 Int_t AliESDEvent::GetNumberOfMuonPads()
1119 // get the number of MUON pads
1120 if (!fMuonPads) return 0;
1121 if (!MoveMuonObjects()) return 0;
1122 return fMuonPads->GetEntriesFast();
1125 //______________________________________________________________________________
1126 AliESDMuonPad* AliESDEvent::GetMuonPad(Int_t i)
1128 // get the MUON pad at the position i in the internal array of pad
1129 if (!fMuonPads) return 0x0;
1130 if (!MoveMuonObjects()) return 0x0;
1131 return (AliESDMuonPad*) fMuonPads->UncheckedAt(i);
1134 //______________________________________________________________________________
1135 AliESDMuonPad* AliESDEvent::FindMuonPad(UInt_t padId)
1137 // find the MUON pad with this Id in the internal array of pad
1138 if (!fMuonPads) return 0x0;
1139 if (!MoveMuonObjects()) return 0x0;
1140 for (Int_t i = 0; i < fMuonPads->GetEntriesFast(); i++) {
1141 AliESDMuonPad *pad = (AliESDMuonPad*) fMuonPads->UncheckedAt(i);
1142 if (pad->GetUniqueID() == padId) return pad;
1147 //______________________________________________________________________________
1148 AliESDMuonPad* AliESDEvent::NewMuonPad()
1150 // create a new MUON pad at the end of the internal array of pad
1151 TClonesArray &fmu = *fMuonPads;
1152 return new(fmu[fMuonPads->GetEntriesFast()]) AliESDMuonPad();
1155 void AliESDEvent::AddPmdTrack(const AliESDPmdTrack *t)
1157 TClonesArray &fpmd = *fPmdTracks;
1158 new(fpmd[fPmdTracks->GetEntriesFast()]) AliESDPmdTrack(*t);
1161 void AliESDEvent::SetTrdTrigger(const AliESDTrdTrigger *t)
1166 void AliESDEvent::AddTrdTrack(const AliESDTrdTrack *t)
1168 TClonesArray &ftrd = *fTrdTracks;
1169 new(ftrd[fTrdTracks->GetEntriesFast()]) AliESDTrdTrack(*t);
1172 void AliESDEvent::AddTrdTracklet(const AliESDTrdTracklet *trkl)
1174 new ((*fTrdTracklets)[fTrdTracklets->GetEntriesFast()]) AliESDTrdTracklet(*trkl);
1177 Int_t AliESDEvent::AddKink(const AliESDkink *c)
1180 TClonesArray &fk = *fKinks;
1181 AliESDkink * kink = new(fk[fKinks->GetEntriesFast()]) AliESDkink(*c);
1182 kink->SetID(fKinks->GetEntriesFast()); // CKB different from the other imps..
1183 return fKinks->GetEntriesFast()-1;
1187 void AliESDEvent::AddCascade(const AliESDcascade *c)
1189 TClonesArray &fc = *fCascades;
1190 new(fc[fCascades->GetEntriesFast()]) AliESDcascade(*c);
1193 void AliESDEvent::AddCosmicTrack(const AliESDCosmicTrack *t)
1195 TClonesArray &ft = *fCosmicTracks;
1196 new(ft[fCosmicTracks->GetEntriesFast()]) AliESDCosmicTrack(*t);
1200 Int_t AliESDEvent::AddCaloCluster(const AliESDCaloCluster *c)
1203 TClonesArray &fc = *fCaloClusters;
1204 AliESDCaloCluster *clus = new(fc[fCaloClusters->GetEntriesFast()]) AliESDCaloCluster(*c);
1205 clus->SetID(fCaloClusters->GetEntriesFast()-1);
1206 return fCaloClusters->GetEntriesFast()-1;
1210 void AliESDEvent::AddRawDataErrorLog(const AliRawDataErrorLog *log) const {
1211 TClonesArray &errlogs = *fErrorLogs;
1212 new(errlogs[errlogs.GetEntriesFast()]) AliRawDataErrorLog(*log);
1215 void AliESDEvent::SetZDCData(const AliESDZDC * obj)
1217 // use already allocated space
1222 void AliESDEvent::SetPrimaryVertexTPC(const AliESDVertex *vertex)
1224 // Set the TPC vertex
1225 // use already allocated space
1227 *fTPCVertex = *vertex;
1228 fTPCVertex->SetName(fgkESDListName[kTPCVertex]);
1232 void AliESDEvent::SetPrimaryVertexSPD(const AliESDVertex *vertex)
1234 // Set the SPD vertex
1235 // use already allocated space
1237 *fSPDVertex = *vertex;
1238 fSPDVertex->SetName(fgkESDListName[kSPDVertex]);
1242 void AliESDEvent::SetPrimaryVertexTracks(const AliESDVertex *vertex)
1244 // Set the primary vertex reconstructed using he ESD tracks.
1245 // use already allocated space
1247 *fPrimaryVertex = *vertex;
1248 fPrimaryVertex->SetName(fgkESDListName[kPrimaryVertex]);
1252 const AliESDVertex * AliESDEvent::GetPrimaryVertex() const
1255 // Get the "best" available reconstructed primary vertex.
1258 if (fPrimaryVertex->GetStatus()) return fPrimaryVertex;
1261 if (fSPDVertex->GetStatus()) return fSPDVertex;
1263 if(fTPCVertex) return fTPCVertex;
1265 AliWarning("No primary vertex available. Returning the \"default\"...");
1269 AliESDVertex * AliESDEvent::PrimaryVertexTracksUnconstrained() const
1272 // Removes diamond constraint from fPrimaryVertex (reconstructed with tracks)
1273 // Returns a AliESDVertex which has to be deleted by the user
1275 if(!fPrimaryVertex) {
1276 AliWarning("No primary vertex from tracks available.");
1279 if(!fPrimaryVertex->GetStatus()) {
1280 AliWarning("No primary vertex from tracks available.");
1284 AliVertexerTracks vertexer(GetMagneticField());
1285 Float_t diamondxyz[3]={(Float_t)GetDiamondX(),(Float_t)GetDiamondY(),0.};
1286 Float_t diamondcovxy[3]; GetDiamondCovXY(diamondcovxy);
1287 Float_t diamondcov[6]={diamondcovxy[0],diamondcovxy[1],diamondcovxy[2],0.,0.,7.};
1288 AliESDVertex *vertex =
1289 (AliESDVertex*)vertexer.RemoveConstraintFromVertex(fPrimaryVertex,diamondxyz,diamondcov);
1294 void AliESDEvent::SetMultiplicity(const AliMultiplicity *mul)
1296 // Set the SPD Multiplicity
1303 void AliESDEvent::SetFMDData(AliESDFMD * obj)
1305 // use already allocated space
1311 void AliESDEvent::SetVZEROData(const AliESDVZERO * obj)
1313 // use already allocated space
1318 void AliESDEvent::SetTZEROData(const AliESDTZERO * obj)
1320 // use already allocated space
1326 //void AliESDEvent::SetMFTData(AliESDMFT * obj)
1333 void AliESDEvent::SetACORDEData(AliESDACORDE * obj)
1340 void AliESDEvent::GetESDfriend(AliESDfriend *ev) const
1343 // Extracts the complementary info from the ESD
1347 Int_t ntrk=GetNumberOfTracks();
1349 for (Int_t i=0; i<ntrk; i++) {
1350 AliESDtrack *t=GetTrack(i);
1351 if (!t) {AliFatal(Form("NULL pointer for ESD track %d",i));}
1352 const AliESDfriendTrack *f=t->GetFriendTrack();
1355 t->ReleaseESDfriendTrack();// Not to have two copies of "friendTrack"
1359 AliESDfriend *fr = (AliESDfriend*)(const_cast<AliESDEvent*>(this)->FindListObject("AliESDfriend"));
1360 if (fr) ev->SetVZEROfriend(fr->GetVZEROfriend());
1363 void AliESDEvent::AddObject(TObject* obj)
1365 // Add an object to the list of object.
1366 // Please be aware that in order to increase performance you should
1367 // refrain from using TObjArrays (if possible). Use TClonesArrays, instead.
1368 fESDObjects->SetOwner(kTRUE);
1369 fESDObjects->AddLast(obj);
1373 void AliESDEvent::GetStdContent()
1375 // set pointers for standard content
1376 // get by name much safer and not a big overhead since not called very often
1378 fESDRun = (AliESDRun*)fESDObjects->FindObject(fgkESDListName[kESDRun]);
1379 fHeader = (AliESDHeader*)fESDObjects->FindObject(fgkESDListName[kHeader]);
1380 fESDZDC = (AliESDZDC*)fESDObjects->FindObject(fgkESDListName[kESDZDC]);
1381 fESDFMD = (AliESDFMD*)fESDObjects->FindObject(fgkESDListName[kESDFMD]);
1382 fESDVZERO = (AliESDVZERO*)fESDObjects->FindObject(fgkESDListName[kESDVZERO]);
1383 fESDTZERO = (AliESDTZERO*)fESDObjects->FindObject(fgkESDListName[kESDTZERO]);
1384 fTPCVertex = (AliESDVertex*)fESDObjects->FindObject(fgkESDListName[kTPCVertex]);
1385 fSPDVertex = (AliESDVertex*)fESDObjects->FindObject(fgkESDListName[kSPDVertex]);
1386 fPrimaryVertex = (AliESDVertex*)fESDObjects->FindObject(fgkESDListName[kPrimaryVertex]);
1387 fSPDMult = (AliMultiplicity*)fESDObjects->FindObject(fgkESDListName[kSPDMult]);
1388 fPHOSTrigger = (AliESDCaloTrigger*)fESDObjects->FindObject(fgkESDListName[kPHOSTrigger]);
1389 fEMCALTrigger = (AliESDCaloTrigger*)fESDObjects->FindObject(fgkESDListName[kEMCALTrigger]);
1390 fSPDPileupVertices = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kSPDPileupVertices]);
1391 fTrkPileupVertices = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kTrkPileupVertices]);
1392 fTracks = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kTracks]);
1393 fMuonTracks = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kMuonTracks]);
1394 fMuonClusters = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kMuonClusters]);
1395 fMuonPads = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kMuonPads]);
1396 fPmdTracks = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kPmdTracks]);
1397 fTrdTrigger = (AliESDTrdTrigger*)fESDObjects->FindObject(fgkESDListName[kTrdTrigger]);
1398 fTrdTracks = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kTrdTracks]);
1399 fTrdTracklets = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kTrdTracklets]);
1400 fV0s = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kV0s]);
1401 fCascades = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kCascades]);
1402 fKinks = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kKinks]);
1403 fCaloClusters = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kCaloClusters]);
1404 fEMCALCells = (AliESDCaloCells*)fESDObjects->FindObject(fgkESDListName[kEMCALCells]);
1405 fPHOSCells = (AliESDCaloCells*)fESDObjects->FindObject(fgkESDListName[kPHOSCells]);
1406 fErrorLogs = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kErrorLogs]);
1407 fESDACORDE = (AliESDACORDE*)fESDObjects->FindObject(fgkESDListName[kESDACORDE]);
1408 fTOFHeader = (AliTOFHeader*)fESDObjects->FindObject(fgkESDListName[kTOFHeader]);
1409 fCosmicTracks = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kCosmicTracks]);
1411 // fESDMFT = (AliESDMFT*)fESDObjects->FindObject(fgkESDListName[kESDMFT]);
1415 void AliESDEvent::SetStdNames(){
1416 // Set the names of the standard contents
1418 if(fESDObjects->GetEntries()>=kESDListN){
1419 for(int i = 0;i < fESDObjects->GetEntries() && i<kESDListN;i++){
1420 TObject *fObj = fESDObjects->At(i);
1421 if(fObj->InheritsFrom("TNamed")){
1422 ((TNamed*)fObj)->SetName(fgkESDListName[i]);
1424 else if(fObj->InheritsFrom("TClonesArray")){
1425 ((TClonesArray*)fObj)->SetName(fgkESDListName[i]);
1430 AliWarning("Std Entries missing");
1435 void AliESDEvent::CreateStdContent(Bool_t bUseThisList){
1436 fUseOwnList = bUseThisList;
1440 void AliESDEvent::CreateStdContent()
1442 // create the standard AOD content and set pointers
1444 // create standard objects and add them to the TList of objects
1445 AddObject(new AliESDRun());
1446 AddObject(new AliESDHeader());
1447 AddObject(new AliESDZDC());
1448 AddObject(new AliESDFMD());
1449 AddObject(new AliESDVZERO());
1450 AddObject(new AliESDTZERO());
1451 AddObject(new AliESDVertex());
1452 AddObject(new AliESDVertex());
1453 AddObject(new AliESDVertex());
1454 AddObject(new AliMultiplicity());
1455 AddObject(new AliESDCaloTrigger());
1456 AddObject(new AliESDCaloTrigger());
1457 AddObject(new TClonesArray("AliESDVertex",0));
1458 AddObject(new TClonesArray("AliESDVertex",0));
1459 AddObject(new TClonesArray("AliESDtrack",0));
1460 AddObject(new TClonesArray("AliESDMuonTrack",0));
1461 AddObject(new TClonesArray("AliESDMuonCluster",0));
1462 AddObject(new TClonesArray("AliESDMuonPad",0));
1463 AddObject(new TClonesArray("AliESDPmdTrack",0));
1464 AddObject(new AliESDTrdTrigger());
1465 AddObject(new TClonesArray("AliESDTrdTrack",0));
1466 AddObject(new TClonesArray("AliESDTrdTracklet",0));
1467 AddObject(new TClonesArray("AliESDv0",0));
1468 AddObject(new TClonesArray("AliESDcascade",0));
1469 AddObject(new TClonesArray("AliESDkink",0));
1470 AddObject(new TClonesArray("AliESDCaloCluster",0));
1471 AddObject(new AliESDCaloCells());
1472 AddObject(new AliESDCaloCells());
1473 AddObject(new TClonesArray("AliRawDataErrorLog",0));
1474 AddObject(new AliESDACORDE());
1475 AddObject(new AliTOFHeader());
1476 AddObject(new TClonesArray("AliESDCosmicTrack",0));
1478 //AddObject(new AliESDMFT());
1481 // check the order of the indices against enum...
1485 // read back pointers
1489 void AliESDEvent::CompleteStdContent()
1491 // create missing standard objects and add them to the TList of objects
1493 // add new MUON containers if missing (for backward compatibility)
1494 if (!fESDObjects->FindObject(fgkESDListName[kMuonClusters])) {
1495 TClonesArray* muonClusters = new TClonesArray("AliESDMuonCluster",0);
1496 muonClusters->SetName(fgkESDListName[kMuonClusters]);
1497 fESDObjects->AddAt(muonClusters, kMuonClusters);
1498 fESDObjects->SetOwner(kTRUE);
1500 if (!fESDObjects->FindObject(fgkESDListName[kMuonPads])) {
1501 TClonesArray* muonPads = new TClonesArray("AliESDMuonPad",0);
1502 muonPads->SetName(fgkESDListName[kMuonPads]);
1503 fESDObjects->AddAt(muonPads, kMuonPads);
1504 fESDObjects->SetOwner(kTRUE);
1508 TObject* AliESDEvent::FindListObject(const char *name) const {
1510 // Find object with name "name" in the list of branches
1513 return fESDObjects->FindObject(name);
1518 Int_t AliESDEvent::GetPHOSClusters(TRefArray *clusters) const
1520 // fills the provided TRefArray with all found phos clusters
1524 AliESDCaloCluster *cl = 0;
1525 for (Int_t i = 0; i < GetNumberOfCaloClusters(); i++) {
1527 if ( (cl = GetCaloCluster(i)) ) {
1530 AliDebug(1,Form("IsPHOS cluster %d Size: %d \n",i,clusters->GetEntriesFast()));
1534 return clusters->GetEntriesFast();
1537 Int_t AliESDEvent::GetEMCALClusters(TRefArray *clusters) const
1539 // fills the provided TRefArray with all found emcal clusters
1543 AliESDCaloCluster *cl = 0;
1544 for (Int_t i = 0; i < GetNumberOfCaloClusters(); i++) {
1546 if ( (cl = GetCaloCluster(i)) ) {
1549 AliDebug(1,Form("IsEMCAL cluster %d Size: %d \n",i,clusters->GetEntriesFast()));
1553 return clusters->GetEntriesFast();
1556 void AliESDEvent::WriteToTree(TTree* tree) const {
1557 // Book the branches as in TTree::Branch(TCollection*)
1558 // but add a "." at the end of top level branches which are
1559 // not a TClonesArray
1563 TIter next(fESDObjects);
1564 const Int_t kSplitlevel = 99; // default value in TTree::Branch()
1565 const Int_t kBufsize = 32000; // default value in TTree::Branch()
1568 while ((obj = next())) {
1569 branchname.Form("%s", obj->GetName());
1570 if(branchname.CompareTo("AliESDfriend")==0)branchname = "ESDfriend.";
1571 if ((kSplitlevel > 1) && !obj->InheritsFrom(TClonesArray::Class())) {
1572 if(!branchname.EndsWith("."))branchname += ".";
1574 if (!tree->FindBranch(branchname)) {
1575 // For the custom streamer to be called splitlevel
1576 // has to be negative, only needed for HLT
1577 Int_t splitLevel = (TString(obj->ClassName()) == "AliHLTGlobalTriggerDecision") ? -1 : kSplitlevel - 1;
1578 tree->Bronch(branchname, obj->ClassName(), fESDObjects->GetObjectRef(obj),kBufsize, splitLevel);
1584 void AliESDEvent::ReadFromTree(TTree *tree, Option_t* opt){
1586 // Connect the ESDEvent to a tree
1589 AliWarning("AliESDEvent::ReadFromTree() Zero Pointer to Tree \n");
1593 if(!tree->GetTree())tree->LoadTree(0);
1595 // if we find the "ESD" branch on the tree we do have the old structure
1596 if(tree->GetBranch("ESD")) {
1597 fOldMuonStructure = kFALSE;
1598 char ** address = (char **)(tree->GetBranch("ESD")->GetAddress());
1599 // do we have the friend branch
1600 TBranch * esdFB = tree->GetBranch("ESDfriend.");
1601 char ** addressF = 0;
1602 if(esdFB)addressF = (char **)(esdFB->GetAddress());
1604 AliInfo("AliESDEvent::ReadFromTree() Reading old Tree");
1605 tree->SetBranchAddress("ESD", &fESDOld);
1607 tree->SetBranchAddress("ESDfriend.",&fESDFriendOld);
1610 AliInfo("AliESDEvent::ReadFromTree() Reading old Tree");
1611 AliInfo("Branch already connected. Using existing branch address.");
1612 fESDOld = (AliESD*) (*address);
1613 // addressF can still be 0, since branch needs to switched on
1614 if(addressF)fESDFriendOld = (AliESDfriend*) (*addressF);
1617 // have already connected the old ESD structure... ?
1618 // reuse also the pointer of the AlliESDEvent
1619 // otherwise create new ones
1620 TList* connectedList = (TList*) (tree->GetUserInfo()->FindObject("ESDObjectsConnectedToTree"));
1623 // If connected use the connected list of objects
1624 if(fESDObjects!= connectedList){
1625 // protect when called twice
1626 fESDObjects->Delete();
1627 fESDObjects = connectedList;
1632 // The pointer to the friend changes when called twice via InitIO
1633 // since AliESDEvent is deleted
1634 TObject* oldf = FindListObject("AliESDfriend");
1637 newf = (TObject*)*addressF;
1639 if(newf!=0&&oldf!=newf){
1640 // remove the old reference
1641 // Should we also delete it? Or is this handled in TTree I/O
1642 // since it is created by the first SetBranchAddress
1643 fESDObjects->Remove(oldf);
1645 fESDObjects->Add(newf);
1652 CreateStdContent(); // create for copy
1653 // if we have the esdfriend add it, so we always can access it via the userinfo
1654 if(fESDFriendOld)AddObject(fESDFriendOld);
1655 // we are not owner of the list objects
1656 // must not delete it
1657 fESDObjects->SetOwner(kTRUE);
1658 fESDObjects->SetName("ESDObjectsConnectedToTree");
1659 tree->GetUserInfo()->Add(fESDObjects);
1667 // Try to find AliESDEvent
1668 AliESDEvent *esdEvent = 0;
1669 esdEvent = (AliESDEvent*)tree->GetTree()->GetUserInfo()->FindObject("AliESDEvent");
1671 // Check if already connected to tree
1673 TList* connectedList = (TList*) (tree->GetUserInfo()->FindObject("ESDObjectsConnectedToTree"));
1676 if (connectedList && (strcmp(opt, "reconnect"))) {
1677 // If connected use the connected list if objects
1678 fESDObjects->Delete();
1679 fESDObjects = connectedList;
1681 fOldMuonStructure = fESDObjects->TestBit(BIT(23));
1687 // prevent a memory leak when reading back the TList
1688 // if (!(strcmp(opt, "reconnect"))) fESDObjects->Delete();
1691 // create a new TList from the UserInfo TList...
1692 // copy constructor does not work...
1693 fESDObjects = (TList*)(esdEvent->GetList()->Clone());
1694 fESDObjects->SetOwner(kTRUE);
1696 else if ( fESDObjects->GetEntries()==0){
1697 // at least create the std content if we want to read to our list
1702 // we only need new things in the list if we do no already have it..
1703 // TODO just add new entries
1704 CompleteStdContent();
1706 if(fESDObjects->GetEntries()<kESDListN){
1707 AliWarning(Form("AliESDEvent::ReadFromTree() TList contains less than the standard contents %d < %d \n",
1708 fESDObjects->GetEntries(),kESDListN));
1710 // set the branch addresses
1711 fOldMuonStructure = kFALSE;
1712 TIter next(fESDObjects);
1714 while((el=(TNamed*)next())){
1715 TString bname(el->GetName());
1716 if(bname.CompareTo("AliESDfriend")==0)
1718 // AliESDfriend does not have a name ...
1719 TBranch *br = tree->GetBranch("ESDfriend.");
1720 if (br) tree->SetBranchAddress("ESDfriend.",fESDObjects->GetObjectRef(el));
1723 // check if branch exists under this Name
1724 TBranch *br = tree->GetBranch(bname.Data());
1726 tree->SetBranchAddress(bname.Data(),fESDObjects->GetObjectRef(el));
1729 br = tree->GetBranch(Form("%s.",bname.Data()));
1731 tree->SetBranchAddress(Form("%s.",bname.Data()),fESDObjects->GetObjectRef(el));
1734 AliWarning(Form("AliESDEvent::ReadFromTree() No Branch found with Name %s or %s.",bname.Data(),bname.Data()));
1735 if (bname == fgkESDListName[kMuonClusters]) {
1736 fOldMuonStructure = kTRUE;
1744 // when reading back we are not owner of the list
1745 // must not delete it
1746 fESDObjects->SetOwner(kTRUE);
1747 fESDObjects->SetName("ESDObjectsConnectedToTree");
1748 fESDObjects->SetBit(BIT(23), fOldMuonStructure);
1749 // we are not owner of the list objects
1750 // must not delete it
1751 tree->GetUserInfo()->Add(fESDObjects);
1752 tree->GetUserInfo()->SetOwner(kFALSE);
1756 // we can't get the list from the user data, create standard content
1757 // and set it by hand (no ESDfriend at the moment
1759 fOldMuonStructure = kFALSE;
1760 TIter next(fESDObjects);
1762 while((el=(TNamed*)next())){
1763 TString bname(el->GetName());
1764 TBranch *br = tree->GetBranch(bname.Data());
1766 tree->SetBranchAddress(bname.Data(),fESDObjects->GetObjectRef(el));
1769 br = tree->GetBranch(Form("%s.",bname.Data()));
1771 tree->SetBranchAddress(Form("%s.",bname.Data()),fESDObjects->GetObjectRef(el));
1773 else if (bname == fgkESDListName[kMuonClusters]) {
1774 fOldMuonStructure = kTRUE;
1779 // when reading back we are not owner of the list
1780 // must not delete it
1781 fESDObjects->SetOwner(kTRUE);
1786 void AliESDEvent::CopyFromOldESD()
1788 // Method which copies over everthing from the old esd structure to the
1793 SetRunNumber(fESDOld->GetRunNumber());
1794 SetPeriodNumber(fESDOld->GetPeriodNumber());
1795 SetMagneticField(fESDOld->GetMagneticField());
1797 // leave out diamond ...
1798 // SetDiamond(const AliESDVertex *vertex) { fESDRun->SetDiamond(vertex);}
1801 SetTriggerMask(fESDOld->GetTriggerMask());
1802 SetOrbitNumber(fESDOld->GetOrbitNumber());
1803 SetTimeStamp(fESDOld->GetTimeStamp());
1804 SetEventType(fESDOld->GetEventType());
1805 SetEventNumberInFile(fESDOld->GetEventNumberInFile());
1806 SetBunchCrossNumber(fESDOld->GetBunchCrossNumber());
1807 SetTriggerCluster(fESDOld->GetTriggerCluster());
1811 SetZDC(fESDOld->GetZDCN1Energy(),
1812 fESDOld->GetZDCP1Energy(),
1813 fESDOld->GetZDCEMEnergy(),
1815 fESDOld->GetZDCN2Energy(),
1816 fESDOld->GetZDCP2Energy(),
1817 fESDOld->GetZDCParticipants(),
1827 if(fESDOld->GetFMDData())SetFMDData(fESDOld->GetFMDData());
1831 SetT0zVertex(fESDOld->GetT0zVertex());
1832 SetT0(fESDOld->GetT0());
1836 if (fESDOld->GetVZEROData()) SetVZEROData(fESDOld->GetVZEROData());
1838 if(fESDOld->GetVertex())SetPrimaryVertexSPD(fESDOld->GetVertex());
1840 if(fESDOld->GetPrimaryVertex())SetPrimaryVertexTracks(fESDOld->GetPrimaryVertex());
1842 if(fESDOld->GetMultiplicity())SetMultiplicity(fESDOld->GetMultiplicity());
1844 for(int i = 0;i<fESDOld->GetNumberOfTracks();i++){
1845 AddTrack(fESDOld->GetTrack(i));
1848 for(int i = 0;i<fESDOld->GetNumberOfMuonTracks();i++){
1849 AddMuonTrack(fESDOld->GetMuonTrack(i));
1852 for(int i = 0;i<fESDOld->GetNumberOfPmdTracks();i++){
1853 AddPmdTrack(fESDOld->GetPmdTrack(i));
1856 for(int i = 0;i<fESDOld->GetNumberOfTrdTracks();i++){
1857 AddTrdTrack(fESDOld->GetTrdTrack(i));
1860 for(int i = 0;i<fESDOld->GetNumberOfV0s();i++){
1861 AddV0(fESDOld->GetV0(i));
1864 for(int i = 0;i<fESDOld->GetNumberOfCascades();i++){
1865 AddCascade(fESDOld->GetCascade(i));
1868 for(int i = 0;i<fESDOld->GetNumberOfKinks();i++){
1869 AddKink(fESDOld->GetKink(i));
1873 for(int i = 0;i<fESDOld->GetNumberOfCaloClusters();i++){
1874 AddCaloCluster(fESDOld->GetCaloCluster(i));
1879 // if (fESDOld->GetMFTData()) SetMFTData(fESDOld->GetMFTData());
1885 Bool_t AliESDEvent::IsEventSelected(const char *trigExpr) const
1887 // Check if the event satisfies the trigger
1888 // selection expression trigExpr.
1889 // trigExpr can be any logical expression
1890 // of the trigger classes defined in AliESDRun
1891 // In case of wrong syntax return kTRUE.
1893 TString expr(trigExpr);
1894 if (expr.IsNull()) return kTRUE;
1896 ULong64_t mask = GetTriggerMask();
1897 for(Int_t itrig = 0; itrig < AliESDRun::kNTriggerClasses; itrig++) {
1898 if (mask & (1ull << itrig)) {
1899 expr.ReplaceAll(GetESDRun()->GetTriggerClass(itrig),"1");
1902 expr.ReplaceAll(GetESDRun()->GetTriggerClass(itrig),"0");
1907 if ((gROOT->ProcessLineFast(expr.Data(),&error) == 0) &&
1908 (error == TInterpreter::kNoError)) {
1916 TObject* AliESDEvent::GetHLTTriggerDecision() const
1918 // get the HLT trigger decission object
1920 // cast away const'nes because the FindListObject method
1922 AliESDEvent* pNonConst=const_cast<AliESDEvent*>(this);
1923 return pNonConst->FindListObject("HLTGlobalTrigger");
1926 TString AliESDEvent::GetHLTTriggerDescription() const
1928 // get the HLT trigger decission description
1929 TString description;
1930 TObject* pDecision=GetHLTTriggerDecision();
1932 description=pDecision->GetTitle();
1938 Bool_t AliESDEvent::IsHLTTriggerFired(const char* name) const
1940 // get the HLT trigger decission description
1941 TObject* pDecision=GetHLTTriggerDecision();
1942 if (!pDecision) return kFALSE;
1944 Option_t* option=pDecision->GetOption();
1945 if (option==NULL || *option!='1') return kFALSE;
1948 TString description=GetHLTTriggerDescription();
1949 Int_t index=description.Index(name);
1950 if (index<0) return kFALSE;
1951 index+=strlen(name);
1952 if (index>=description.Length()) return kFALSE;
1953 if (description[index]!=0 && description[index]!=' ') return kFALSE;
1958 //______________________________________________________________________________
1959 Bool_t AliESDEvent::IsPileupFromSPD(Int_t minContributors,
1961 Double_t nSigmaZdist,
1962 Double_t nSigmaDiamXY,
1963 Double_t nSigmaDiamZ) const{
1965 // This function checks if there was a pile up
1966 // reconstructed with SPD
1968 Int_t nc1=fSPDVertex->GetNContributors();
1969 if(nc1<1) return kFALSE;
1970 Int_t nPileVert=GetNumberOfPileupVerticesSPD();
1971 if(nPileVert==0) return kFALSE;
1973 for(Int_t i=0; i<nPileVert;i++){
1974 const AliESDVertex* pv=GetPileupVertexSPD(i);
1975 Int_t nc2=pv->GetNContributors();
1976 if(nc2>=minContributors){
1977 Double_t z1=fSPDVertex->GetZ();
1978 Double_t z2=pv->GetZ();
1979 Double_t distZ=TMath::Abs(z2-z1);
1980 Double_t distZdiam=TMath::Abs(z2-GetDiamondZ());
1981 Double_t cutZdiam=nSigmaDiamZ*TMath::Sqrt(GetSigma2DiamondZ());
1982 if(GetSigma2DiamondZ()<0.0001)cutZdiam=99999.; //protection for missing z diamond information
1983 if(distZ>minZdist && distZdiam<cutZdiam){
1984 Double_t x2=pv->GetX();
1985 Double_t y2=pv->GetY();
1986 Double_t distXdiam=TMath::Abs(x2-GetDiamondX());
1987 Double_t distYdiam=TMath::Abs(y2-GetDiamondY());
1988 Double_t cov1[6],cov2[6];
1989 fSPDVertex->GetCovarianceMatrix(cov1);
1990 pv->GetCovarianceMatrix(cov2);
1991 Double_t errxDist=TMath::Sqrt(cov2[0]+GetSigma2DiamondX());
1992 Double_t erryDist=TMath::Sqrt(cov2[2]+GetSigma2DiamondY());
1993 Double_t errzDist=TMath::Sqrt(cov1[5]+cov2[5]);
1994 Double_t cutXdiam=nSigmaDiamXY*errxDist;
1995 if(GetSigma2DiamondX()<0.0001)cutXdiam=99999.; //protection for missing diamond information
1996 Double_t cutYdiam=nSigmaDiamXY*erryDist;
1997 if(GetSigma2DiamondY()<0.0001)cutYdiam=99999.; //protection for missing diamond information
1998 if( (distXdiam<cutXdiam) && (distYdiam<cutYdiam) && (distZ>nSigmaZdist*errzDist) ){
2007 //______________________________________________________________________________
2008 void AliESDEvent::EstimateMultiplicity(Int_t &tracklets, Int_t &trITSTPC, Int_t &trITSSApure, Double_t eta, Bool_t useDCAFlag,Bool_t useV0Flag) const
2011 // calculates 3 estimators for the multiplicity in the -eta:eta range
2012 // tracklets : using SPD tracklets only
2013 // trITSTPC : using TPC/ITS + complementary ITS SA tracks + tracklets from clusters not used by tracks
2014 // trITSSApure : using ITS standalone tracks + tracklets from clusters not used by tracks
2015 // if useDCAFlag is true: account for the ESDtrack flag marking the tracks with large DCA
2016 // if useV0Flag is true: account for the ESDtrack flag marking conversion and K0's V0s
2018 AliWarning("This obsolete method will be eliminated soon. Use AliESDtrackCuts::GetReferenceMultiplicity");
2020 tracklets = trITSSApure = trITSTPC = 0;
2021 int ntr = fSPDMult ? fSPDMult->GetNumberOfTracklets() : 0;
2024 for (int itr=ntr;itr--;) {
2025 if (TMath::Abs(fSPDMult->GetEta(itr))>eta) continue;
2027 if (fSPDMult->FreeClustersTracklet(itr,0)) trITSTPC++; // not used in ITS/TPC or ITS_SA track
2028 if (fSPDMult->FreeClustersTracklet(itr,1)) trITSSApure++; // not used in ITS_SA_Pure track
2031 // count real tracks
2032 ntr = GetNumberOfTracks();
2033 for (int itr=ntr;itr--;) {
2034 AliESDtrack *t = GetTrack(itr);
2035 if (!t) {AliFatal(Form("NULL pointer for ESD track %d",itr));}
2036 if (TMath::Abs(t->Eta())>eta) continue;
2037 if (!t->IsOn(AliESDtrack::kITSin)) continue;
2038 if (useDCAFlag && t->IsOn(AliESDtrack::kMultSec)) continue;
2039 if (useV0Flag && t->IsOn(AliESDtrack::kMultInV0)) continue;
2040 if (t->IsOn(AliESDtrack::kITSpureSA)) trITSSApure++;
2046 Bool_t AliESDEvent::IsPileupFromSPDInMultBins() const {
2047 Int_t nTracklets=GetMultiplicity()->GetNumberOfTracklets();
2048 if(nTracklets<20) return IsPileupFromSPD(3,0.8);
2049 else if(nTracklets<50) return IsPileupFromSPD(4,0.8);
2050 else return IsPileupFromSPD(5,0.8);
2053 void AliESDEvent::SetTOFHeader(const AliTOFHeader *header)
2056 // Set the TOF event_time
2060 *fTOFHeader=*header;
2061 //fTOFHeader->SetName(fgkESDListName[kTOFHeader]);
2064 // for analysis of reconstructed events
2065 // when this information is not avaliable
2066 fTOFHeader = new AliTOFHeader(*header);
2067 //AddObject(fTOFHeader);
2072 AliCentrality* AliESDEvent::GetCentrality()
2074 if (!fCentrality) fCentrality = new AliCentrality();
2078 AliEventplane* AliESDEvent::GetEventplane()
2080 if (!fEventplane) fEventplane = new AliEventplane();
2084 Float_t AliESDEvent::GetVZEROEqMultiplicity(Int_t i) const
2086 // Get VZERO Multiplicity for channel i
2087 // Themethod uses the equalization factors
2088 // stored in the ESD-run object in order to
2089 // get equal multiplicities within a VZERO rins (1/8 of VZERO)
2090 if (!fESDVZERO || !fESDRun) return -1;
2093 Float_t factorSum = 0;
2094 for(Int_t j = 8*ring; j < (8*ring+8); ++j) {
2095 factorSum += fESDRun->GetVZEROEqFactors(j);
2097 Float_t factor = fESDRun->GetVZEROEqFactors(i)*8./factorSum;
2099 return (fESDVZERO->GetMultiplicity(i)/factor);