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 "AliESDPmdTrack.h"
48 #include "AliESDTrdTrack.h"
49 #include "AliESDVertex.h"
50 #include "AliESDcascade.h"
51 #include "AliESDPmdTrack.h"
52 #include "AliESDTrdTrack.h"
53 #include "AliESDVertex.h"
54 #include "AliVertexerTracks.h"
55 #include "AliESDcascade.h"
56 #include "AliESDkink.h"
57 #include "AliESDtrack.h"
58 #include "AliESDHLTtrack.h"
59 #include "AliESDCaloCluster.h"
60 #include "AliESDCaloCells.h"
62 #include "AliESDFMD.h"
63 #include "AliESDVZERO.h"
64 #include "AliMultiplicity.h"
65 #include "AliRawDataErrorLog.h"
67 #include "AliESDACORDE.h"
68 #include "AliESDHLTDecision.h"
74 // here we define the names, some classes are no TNamed, therefore the classnames
76 const char* AliESDEvent::fgkESDListName[kESDListN] = {"AliESDRun",
100 "AliRawDataErrorLogs",
103 //______________________________________________________________________________
104 AliESDEvent::AliESDEvent():
106 fESDObjects(new TList()),
120 fSPDPileupVertices(0),
121 fTrkPileupVertices(0),
130 fEMCALCells(0), fPHOSCells(0),
137 fFirstEMCALCluster(-1),
139 fFirstPHOSCluster(-1)
142 //______________________________________________________________________________
143 AliESDEvent::AliESDEvent(const AliESDEvent& esd):
145 fESDObjects(new TList()),
146 fESDRun(new AliESDRun(*esd.fESDRun)),
147 fHeader(new AliESDHeader(*esd.fHeader)),
148 fESDZDC(new AliESDZDC(*esd.fESDZDC)),
149 fESDFMD(new AliESDFMD(*esd.fESDFMD)),
150 fESDVZERO(new AliESDVZERO(*esd.fESDVZERO)),
151 fESDTZERO(new AliESDTZERO(*esd.fESDTZERO)),
152 fTPCVertex(new AliESDVertex(*esd.fTPCVertex)),
153 fSPDVertex(new AliESDVertex(*esd.fSPDVertex)),
154 fPrimaryVertex(new AliESDVertex(*esd.fPrimaryVertex)),
155 fSPDMult(new AliMultiplicity(*esd.fSPDMult)),
156 fPHOSTrigger(new AliESDCaloTrigger(*esd.fPHOSTrigger)),
157 fEMCALTrigger(new AliESDCaloTrigger(*esd.fEMCALTrigger)),
158 fESDACORDE(new AliESDACORDE(*esd.fESDACORDE)),
159 fSPDPileupVertices(new TClonesArray(*esd.fSPDPileupVertices)),
160 fTrkPileupVertices(new TClonesArray(*esd.fTrkPileupVertices)),
161 fTracks(new TClonesArray(*esd.fTracks)),
162 fMuonTracks(new TClonesArray(*esd.fMuonTracks)),
163 fPmdTracks(new TClonesArray(*esd.fPmdTracks)),
164 fTrdTracks(new TClonesArray(*esd.fTrdTracks)),
165 fV0s(new TClonesArray(*esd.fV0s)),
166 fCascades(new TClonesArray(*esd.fCascades)),
167 fKinks(new TClonesArray(*esd.fKinks)),
168 fCaloClusters(new TClonesArray(*esd.fCaloClusters)),
169 fEMCALCells(new AliESDCaloCells(*esd.fEMCALCells)),
170 fPHOSCells(new AliESDCaloCells(*esd.fPHOSCells)),
171 fErrorLogs(new TClonesArray(*esd.fErrorLogs)),
172 fESDOld(esd.fESDOld ? new AliESD(*esd.fESDOld) : 0),
173 fESDFriendOld(esd.fESDFriendOld ? new AliESDfriend(*esd.fESDFriendOld) : 0),
174 fConnected(esd.fConnected),
175 fUseOwnList(esd.fUseOwnList),
176 fEMCALClusters(esd.fEMCALClusters),
177 fFirstEMCALCluster(esd.fFirstEMCALCluster),
178 fPHOSClusters(esd.fPHOSClusters),
179 fFirstPHOSCluster(esd.fFirstPHOSCluster)
182 // CKB init in the constructor list and only add here ...
187 AddObject(fESDVZERO);
188 AddObject(fESDTZERO);
189 AddObject(fTPCVertex);
190 AddObject(fSPDVertex);
191 AddObject(fPrimaryVertex);
193 AddObject(fPHOSTrigger);
194 AddObject(fEMCALTrigger);
195 AddObject(fSPDPileupVertices);
196 AddObject(fTrkPileupVertices);
198 AddObject(fMuonTracks);
199 AddObject(fPmdTracks);
200 AddObject(fTrdTracks);
202 AddObject(fCascades);
204 AddObject(fCaloClusters);
205 AddObject(fEMCALCells);
206 AddObject(fPHOSCells);
207 AddObject(fErrorLogs);
208 AddObject(fESDACORDE);
214 //______________________________________________________________________________
215 AliESDEvent & AliESDEvent::operator=(const AliESDEvent& source) {
217 // Assignment operator
219 if(&source == this) return *this;
220 AliVEvent::operator=(source);
222 // This assumes that the list is already created
223 // and that the virtual void Copy(Tobject&) function
224 // is correctly implemented in the derived class
225 // otherwise only TObject::Copy() will be used
229 if((fESDObjects->GetSize()==0)&&(source.fESDObjects->GetSize()>=kESDListN)){
230 // We cover the case that we do not yet have the
231 // standard content but the source has it
235 TIter next(source.GetList());
238 while ((its = next())) {
239 name.Form("%s", its->GetName());
240 TObject *mine = fESDObjects->FindObject(name.Data());
242 TClass* pClass=TClass::GetClass(its->ClassName());
244 AliWarning(Form("Can not find class description for entry %s (%s)\n",
245 its->ClassName(), name.Data()));
249 mine=(TObject*)pClass->New();
251 // not in this: can be added to list
252 AliWarning(Form("%s:%d Could not find %s for copying \n",
253 (char*)__FILE__,__LINE__,name.Data()));
256 if(mine->InheritsFrom("TNamed")){
257 ((TNamed*)mine)->SetName(name);
259 else if(mine->InheritsFrom("TCollection")){
260 if(mine->InheritsFrom("TClonesArray"))
261 dynamic_cast<TClonesArray*>(mine)->SetClass(dynamic_cast<TClonesArray*>(its)->GetClass());
262 dynamic_cast<TCollection*>(mine)->SetName(name);
264 AliDebug(1, Form("adding object %s of type %s", mine->GetName(), mine->ClassName()));
268 if(!its->InheritsFrom("TCollection")){
272 else if(its->InheritsFrom("TClonesArray")){
273 // Create or expand the tclonesarray pointers
274 // so we can directly copy to the object
275 TClonesArray *its_tca = (TClonesArray*)its;
276 TClonesArray *mine_tca = (TClonesArray*)mine;
278 // this leaves the capacity of the TClonesArray the same
279 // except for a factor of 2 increase when size > capacity
280 // does not release any memory occupied by the tca
281 mine_tca->ExpandCreate(its_tca->GetEntriesFast());
282 for(int i = 0;i < its_tca->GetEntriesFast();++i){
284 TObject *mine_tca_obj = mine_tca->At(i);
285 TObject *its_tca_obj = its_tca->At(i);
286 // no need to delete first
287 // pointers within the class should be handled by Copy()...
288 // Can there be Empty slots?
289 its_tca_obj->Copy(*mine_tca_obj);
293 AliWarning(Form("%s:%d cannot copy TCollection \n",
294 (char*)__FILE__,__LINE__));
298 fConnected = source.fConnected;
299 fUseOwnList = source.fUseOwnList;
300 fEMCALClusters = source.fEMCALClusters;
301 fFirstEMCALCluster = source.fFirstEMCALCluster;
302 fPHOSClusters = source.fPHOSClusters;
303 fFirstPHOSCluster = source.fFirstPHOSCluster;
311 //______________________________________________________________________________
312 AliESDEvent::~AliESDEvent()
315 // Standard destructor
318 // everthing on the list gets deleted automatically
321 if(fESDObjects&&!fConnected)
330 void AliESDEvent::Copy(TObject &obj) const {
332 // interface to TOBject::Copy
333 // Copies the content of this into obj!
334 // bascially obj = *this
336 if(this==&obj)return;
337 AliESDEvent *robj = dynamic_cast<AliESDEvent*>(&obj);
338 if(!robj)return; // not an AliESEvent
343 //______________________________________________________________________________
344 void AliESDEvent::Reset()
348 // Std content + Non std content
350 // Reset the standard contents
353 // reset for the old data without AliESDEvent...
354 if(fESDOld)fESDOld->Reset();
356 fESDFriendOld->~AliESDfriend();
357 new (fESDFriendOld) AliESDfriend();
361 if(fESDObjects->GetSize()>kESDListN){
362 // we have non std content
363 // this also covers esdfriends
364 for(int i = kESDListN;i < fESDObjects->GetSize();++i){
365 TObject *pObject = fESDObjects->At(i);
367 if(pObject->InheritsFrom(TClonesArray::Class())){
368 ((TClonesArray*)pObject)->Delete();
370 else if(!pObject->InheritsFrom(TCollection::Class())){
371 ResetWithPlacementNew(pObject);
374 AliWarning(Form("No reset for %s (%s)\n",
375 pObject->ClassName()));
382 Bool_t AliESDEvent::ResetWithPlacementNew(TObject *pObject){
383 Long_t dtoronly = TObject::GetDtorOnly();
384 TClass *pClass = TClass::GetClass(pObject->ClassName());
385 TObject::SetDtorOnly(pObject);
387 // Recreate with placement new
388 pClass->New(pObject);
389 // Restore the state.
390 TObject::SetDtorOnly((void*)dtoronly);
394 void AliESDEvent::ResetStdContent()
396 // Reset the standard contents
397 if(fESDRun) fESDRun->Reset();
398 if(fHeader) fHeader->Reset();
399 if(fESDZDC) fESDZDC->Reset();
404 // reset by callin d'to /c'tor keep the pointer
405 fESDVZERO->~AliESDVZERO();
406 new (fESDVZERO) AliESDVZERO();
409 fESDACORDE->~AliESDACORDE();
410 new (fESDACORDE) AliESDACORDE();
412 if(fESDTZERO) fESDTZERO->Reset();
413 // CKB no clear/reset implemented
415 fTPCVertex->~AliESDVertex();
416 new (fTPCVertex) AliESDVertex();
417 fTPCVertex->SetName(fgkESDListName[kTPCVertex]);
420 fSPDVertex->~AliESDVertex();
421 new (fSPDVertex) AliESDVertex();
422 fSPDVertex->SetName(fgkESDListName[kSPDVertex]);
425 fPrimaryVertex->~AliESDVertex();
426 new (fPrimaryVertex) AliESDVertex();
427 fPrimaryVertex->SetName(fgkESDListName[kPrimaryVertex]);
430 fSPDMult->~AliMultiplicity();
431 new (fSPDMult) AliMultiplicity();
433 if(fPHOSTrigger)fPHOSTrigger->Reset();
434 if(fEMCALTrigger)fEMCALTrigger->Reset();
435 if(fSPDPileupVertices)fSPDPileupVertices->Delete();
436 if(fTrkPileupVertices)fTrkPileupVertices->Delete();
437 if(fTracks)fTracks->Delete();
438 if(fMuonTracks)fMuonTracks->Delete();
439 if(fPmdTracks)fPmdTracks->Delete();
440 if(fTrdTracks)fTrdTracks->Delete();
441 if(fV0s)fV0s->Delete();
442 if(fCascades)fCascades->Delete();
443 if(fKinks)fKinks->Delete();
444 if(fCaloClusters)fCaloClusters->Delete();
445 if(fPHOSCells)fPHOSCells->DeleteContainer();
446 if(fEMCALCells)fEMCALCells->DeleteContainer();
447 if(fErrorLogs) fErrorLogs->Delete();
449 // don't reset fconnected fConnected and the list
452 fFirstEMCALCluster=-1;
454 fFirstPHOSCluster=-1;
458 Int_t AliESDEvent::AddV0(const AliESDv0 *v) {
462 TClonesArray &fv = *fV0s;
463 Int_t idx=fV0s->GetEntriesFast();
464 new(fv[idx]) AliESDv0(*v);
468 //______________________________________________________________________________
469 void AliESDEvent::Print(Option_t *) const
472 // Print header information of the event
474 printf("ESD run information\n");
475 printf("Event # in file %d Bunch crossing # %d Orbit # %d Period # %d Run # %d Trigger %lld Magnetic field %f \n",
476 GetEventNumberInFile(),
477 GetBunchCrossNumber(),
482 GetMagneticField() );
484 printf("Vertex: (%.4f +- %.4f, %.4f +- %.4f, %.4f +- %.4f) cm\n",
485 fPrimaryVertex->GetXv(), fPrimaryVertex->GetXRes(),
486 fPrimaryVertex->GetYv(), fPrimaryVertex->GetYRes(),
487 fPrimaryVertex->GetZv(), fPrimaryVertex->GetZRes());
488 printf("Mean vertex in RUN: X=%.4f Y=%.4f cm\n",
489 GetDiamondX(),GetDiamondY());
491 printf("SPD Multiplicity. Number of tracklets %d \n",
492 fSPDMult->GetNumberOfTracklets());
493 printf("Number of pileup primary vertices reconstructed with SPD %d\n",
494 GetNumberOfPileupVerticesSPD());
495 printf("Number of pileup primary vertices reconstructed using the tracks %d\n",
496 GetNumberOfPileupVerticesTracks());
497 printf("Number of tracks: \n");
498 printf(" charged %d\n", GetNumberOfTracks());
499 printf(" muon %d\n", GetNumberOfMuonTracks());
500 printf(" pmd %d\n", GetNumberOfPmdTracks());
501 printf(" trd %d\n", GetNumberOfTrdTracks());
502 printf(" v0 %d\n", GetNumberOfV0s());
503 printf(" cascades %d\n", GetNumberOfCascades());
504 printf(" kinks %d\n", GetNumberOfKinks());
505 if(fPHOSCells)printf(" PHOSCells %d\n", fPHOSCells->GetNumberOfCells());
506 else printf(" PHOSCells not in the Event\n");
507 if(fEMCALCells)printf(" EMCALCells %d\n", fEMCALCells->GetNumberOfCells());
508 else printf(" EMCALCells not in the Event\n");
509 printf(" CaloClusters %d\n", GetNumberOfCaloClusters());
510 printf(" phos %d\n", GetNumberOfPHOSClusters());
511 printf(" emcal %d\n", GetNumberOfEMCALClusters());
512 printf(" FMD %s\n", (fESDFMD ? "yes" : "no"));
513 printf(" VZERO %s\n", (fESDVZERO ? "yes" : "no"));
514 TObject* pHLTDecision=GetHLTTriggerDecision();
515 printf("HLT trigger decision: %s\n", pHLTDecision?pHLTDecision->GetOption():"not available");
516 if (pHLTDecision) pHLTDecision->Print("compact");
521 void AliESDEvent::SetESDfriend(const AliESDfriend *ev) const {
523 // Attaches the complementary info to the ESD
527 // to be sure that we set the tracks also
528 // in case of old esds
529 // if(fESDOld)CopyFromOldESD();
531 Int_t ntrk=ev->GetNumberOfTracks();
533 for (Int_t i=0; i<ntrk; i++) {
534 const AliESDfriendTrack *f=ev->GetTrack(i);
535 GetTrack(i)->SetFriendTrack(f);
539 Bool_t AliESDEvent::RemoveKink(Int_t rm) const {
540 // ---------------------------------------------------------
541 // Remove a kink candidate and references to it from ESD,
542 // if this candidate does not come from a reconstructed decay
543 // Not yet implemented...
544 // ---------------------------------------------------------
545 Int_t last=GetNumberOfKinks()-1;
546 if ((rm<0)||(rm>last)) return kFALSE;
551 Bool_t AliESDEvent::RemoveV0(Int_t rm) const {
552 // ---------------------------------------------------------
553 // Remove a V0 candidate and references to it from ESD,
554 // if this candidate does not come from a reconstructed decay
555 // ---------------------------------------------------------
556 Int_t last=GetNumberOfV0s()-1;
557 if ((rm<0)||(rm>last)) return kFALSE;
559 AliESDv0 *v0=GetV0(rm);
560 Int_t idxP=v0->GetPindex(), idxN=v0->GetNindex();
563 Int_t lastIdxP=v0->GetPindex(), lastIdxN=v0->GetNindex();
567 // Check if this V0 comes from a reconstructed decay
568 Int_t ncs=GetNumberOfCascades();
569 for (Int_t n=0; n<ncs; n++) {
570 AliESDcascade *cs=GetCascade(n);
572 Int_t csIdxP=cs->GetPindex();
573 Int_t csIdxN=cs->GetNindex();
576 if (idxN==csIdxN) return kFALSE;
578 if (csIdxP==lastIdxP)
579 if (csIdxN==lastIdxN) used++;
582 //Replace the removed V0 with the last V0
583 TClonesArray &a=*fV0s;
584 delete a.RemoveAt(rm);
586 if (rm==last) return kTRUE;
588 //v0 is pointing to the last V0 candidate...
589 new (a[rm]) AliESDv0(*v0);
590 delete a.RemoveAt(last);
592 if (!used) return kTRUE;
595 // Remap the indices of the daughters of reconstructed decays
596 for (Int_t n=0; n<ncs; n++) {
597 AliESDcascade *cs=GetCascade(n);
600 Int_t csIdxP=cs->GetPindex();
601 Int_t csIdxN=cs->GetNindex();
603 if (csIdxP==lastIdxP)
604 if (csIdxN==lastIdxN) {
605 cs->AliESDv0::SetIndex(1,idxP);
606 cs->AliESDv0::SetIndex(0,idxN);
608 if (!used) return kTRUE;
615 Bool_t AliESDEvent::RemoveTrack(Int_t rm) const {
616 // ---------------------------------------------------------
617 // Remove a track and references to it from ESD,
618 // if this track does not come from a reconstructed decay
619 // ---------------------------------------------------------
620 Int_t last=GetNumberOfTracks()-1;
621 if ((rm<0)||(rm>last)) return kFALSE;
625 // Check if this track comes from the reconstructed primary vertices
626 if (fTPCVertex && fTPCVertex->GetStatus()) {
627 UShort_t *primIdx=fTPCVertex->GetIndices();
628 Int_t n=fTPCVertex->GetNIndices();
630 Int_t idx=Int_t(primIdx[n]);
631 if (rm==idx) return kFALSE;
632 if (idx==last) used++;
635 if (fPrimaryVertex && fPrimaryVertex->GetStatus()) {
636 UShort_t *primIdx=fPrimaryVertex->GetIndices();
637 Int_t n=fPrimaryVertex->GetNIndices();
639 Int_t idx=Int_t(primIdx[n]);
640 if (rm==idx) return kFALSE;
641 if (idx==last) used++;
645 // Check if this track comes from a reconstructed decay
646 Int_t nv0=GetNumberOfV0s();
647 for (Int_t n=0; n<nv0; n++) {
648 AliESDv0 *v0=GetV0(n);
650 Int_t idx=v0->GetNindex();
651 if (rm==idx) return kFALSE;
652 if (idx==last) used++;
655 if (rm==idx) return kFALSE;
656 if (idx==last) used++;
659 Int_t ncs=GetNumberOfCascades();
660 for (Int_t n=0; n<ncs; n++) {
661 AliESDcascade *cs=GetCascade(n);
663 Int_t idx=cs->GetIndex();
664 if (rm==idx) return kFALSE;
665 if (idx==last) used++;
669 if (rm==idx) return kFALSE;
670 if (idx==last) used++;
673 if (rm==idx) return kFALSE;
674 if (idx==last) used++;
677 Int_t nkn=GetNumberOfKinks();
678 for (Int_t n=0; n<nkn; n++) {
679 AliESDkink *kn=GetKink(n);
681 Int_t idx=kn->GetIndex(0);
682 if (rm==idx) return kFALSE;
683 if (idx==last) used++;
686 if (rm==idx) return kFALSE;
687 if (idx==last) used++;
690 // Check if this track is associated with a CaloCluster
691 Int_t ncl=GetNumberOfCaloClusters();
692 for (Int_t n=0; n<ncl; n++) {
693 AliESDCaloCluster *cluster=GetCaloCluster(n);
694 TArrayI *arr=cluster->GetTracksMatched();
695 Int_t s=arr->GetSize();
697 Int_t idx=arr->At(s);
698 if (rm==idx) return kFALSE;
699 if (idx==last) used++;
705 //Replace the removed track with the last track
706 TClonesArray &a=*fTracks;
707 delete a.RemoveAt(rm);
709 if (rm==last) return kTRUE;
711 AliESDtrack *t=GetTrack(last);
713 new (a[rm]) AliESDtrack(*t);
714 delete a.RemoveAt(last);
717 if (!used) return kTRUE;
720 // Remap the indices of the tracks used for the primary vertex reconstruction
721 if (fTPCVertex && fTPCVertex->GetStatus()) {
722 UShort_t *primIdx=fTPCVertex->GetIndices();
723 Int_t n=fTPCVertex->GetNIndices();
725 Int_t idx=Int_t(primIdx[n]);
727 primIdx[n]=Short_t(rm);
729 if (!used) return kTRUE;
733 if (fPrimaryVertex && fPrimaryVertex->GetStatus()) {
734 UShort_t *primIdx=fPrimaryVertex->GetIndices();
735 Int_t n=fPrimaryVertex->GetNIndices();
737 Int_t idx=Int_t(primIdx[n]);
739 primIdx[n]=Short_t(rm);
741 if (!used) return kTRUE;
746 // Remap the indices of the daughters of reconstructed decays
747 for (Int_t n=0; n<nv0; n++) {
748 AliESDv0 *v0=GetV0(n);
749 if (v0->GetIndex(0)==last) {
752 if (!used) return kTRUE;
754 if (v0->GetIndex(1)==last) {
757 if (!used) return kTRUE;
761 for (Int_t n=0; n<ncs; n++) {
762 AliESDcascade *cs=GetCascade(n);
763 if (cs->GetIndex()==last) {
766 if (!used) return kTRUE;
769 if (v0->GetIndex(0)==last) {
772 if (!used) return kTRUE;
774 if (v0->GetIndex(1)==last) {
777 if (!used) return kTRUE;
781 for (Int_t n=0; n<nkn; n++) {
782 AliESDkink *kn=GetKink(n);
783 if (kn->GetIndex(0)==last) {
786 if (!used) return kTRUE;
788 if (kn->GetIndex(1)==last) {
791 if (!used) return kTRUE;
795 // Remap the indices of the tracks accosicated with CaloClusters
796 for (Int_t n=0; n<ncl; n++) {
797 AliESDCaloCluster *cluster=GetCaloCluster(n);
798 TArrayI *arr=cluster->GetTracksMatched();
799 Int_t s=arr->GetSize();
801 Int_t idx=arr->At(s);
805 if (!used) return kTRUE;
814 Bool_t AliESDEvent::Clean(Float_t *cleanPars) {
816 // Remove the data which are not needed for the physics analysis.
818 // 1) Cleaning the V0 candidates
819 // ---------------------------
820 // If the cosine of the V0 pointing angle "csp" and
821 // the DCA between the daughter tracks "dca" does not satisfy
824 // csp > cleanPars[1] + dca/cleanPars[0]*(1.- cleanPars[1])
826 // an attempt to remove this V0 candidate from ESD is made.
828 // The V0 candidate gets removed if it does not belong to any
829 // recosntructed cascade decay
831 // 12.11.2007, optimal values: cleanPars[0]=0.5, cleanPars[1]=0.999
833 // 2) Cleaning the tracks
834 // ----------------------
835 // If track's transverse parameter is larger than cleanPars[2]
837 // track's longitudinal parameter is larger than cleanPars[3]
838 // an attempt to remove this track from ESD is made.
840 // The track gets removed if it does not come
841 // from a reconstructed decay
845 Float_t dcaMax=cleanPars[0];
846 Float_t cspMin=cleanPars[1];
848 Int_t nV0s=GetNumberOfV0s();
849 for (Int_t i=nV0s-1; i>=0; i--) {
850 AliESDv0 *v0=GetV0(i);
852 Float_t dca=v0->GetDcaV0Daughters();
853 Float_t csp=v0->GetV0CosineOfPointingAngle();
854 Float_t cspcut=cspMin + dca/dcaMax*(1.-cspMin);
855 if (csp > cspcut) continue;
856 if (RemoveV0(i)) rc=kTRUE;
860 Float_t dmax=cleanPars[2], zmax=cleanPars[3];
862 const AliESDVertex *vertex=GetPrimaryVertexSPD();
863 Bool_t vtxOK=vertex->GetStatus();
865 Int_t nTracks=GetNumberOfTracks();
866 for (Int_t i=nTracks-1; i>=0; i--) {
867 AliESDtrack *track=GetTrack(i);
868 Float_t xy,z; track->GetImpactParameters(xy,z);
869 if ((TMath::Abs(xy) > dmax) || (vtxOK && (TMath::Abs(z) > zmax))) {
870 if (RemoveTrack(i)) rc=kTRUE;
877 Char_t AliESDEvent::AddPileupVertexSPD(const AliESDVertex *vtx)
879 // Add a pileup primary vertex reconstructed with SPD
880 TClonesArray &ftr = *fSPDPileupVertices;
881 Char_t n=Char_t(ftr.GetEntriesFast());
882 AliESDVertex *vertex = new(ftr[n]) AliESDVertex(*vtx);
887 Char_t AliESDEvent::AddPileupVertexTracks(const AliESDVertex *vtx)
889 // Add a pileup primary vertex reconstructed with SPD
890 TClonesArray &ftr = *fTrkPileupVertices;
891 Char_t n=Char_t(ftr.GetEntriesFast());
892 AliESDVertex *vertex = new(ftr[n]) AliESDVertex(*vtx);
897 Int_t AliESDEvent::AddTrack(const AliESDtrack *t)
900 TClonesArray &ftr = *fTracks;
901 AliESDtrack * track = new(ftr[fTracks->GetEntriesFast()])AliESDtrack(*t);
902 track->SetID(fTracks->GetEntriesFast()-1);
903 return track->GetID();
906 void AliESDEvent::AddMuonTrack(const AliESDMuonTrack *t)
908 TClonesArray &fmu = *fMuonTracks;
909 new(fmu[fMuonTracks->GetEntriesFast()]) AliESDMuonTrack(*t);
912 void AliESDEvent::AddPmdTrack(const AliESDPmdTrack *t)
914 TClonesArray &fpmd = *fPmdTracks;
915 new(fpmd[fPmdTracks->GetEntriesFast()]) AliESDPmdTrack(*t);
918 void AliESDEvent::AddTrdTrack(const AliESDTrdTrack *t)
920 TClonesArray &ftrd = *fTrdTracks;
921 new(ftrd[fTrdTracks->GetEntriesFast()]) AliESDTrdTrack(*t);
927 Int_t AliESDEvent::AddKink(const AliESDkink *c)
930 TClonesArray &fk = *fKinks;
931 AliESDkink * kink = new(fk[fKinks->GetEntriesFast()]) AliESDkink(*c);
932 kink->SetID(fKinks->GetEntriesFast()); // CKB different from the other imps..
933 return fKinks->GetEntriesFast()-1;
937 void AliESDEvent::AddCascade(const AliESDcascade *c)
939 TClonesArray &fc = *fCascades;
940 new(fc[fCascades->GetEntriesFast()]) AliESDcascade(*c);
944 Int_t AliESDEvent::AddCaloCluster(const AliESDCaloCluster *c)
947 TClonesArray &fc = *fCaloClusters;
948 AliESDCaloCluster *clus = new(fc[fCaloClusters->GetEntriesFast()]) AliESDCaloCluster(*c);
949 clus->SetID(fCaloClusters->GetEntriesFast()-1);
950 return fCaloClusters->GetEntriesFast()-1;
954 void AliESDEvent::AddRawDataErrorLog(const AliRawDataErrorLog *log) const {
955 TClonesArray &errlogs = *fErrorLogs;
956 new(errlogs[errlogs.GetEntriesFast()]) AliRawDataErrorLog(*log);
959 void AliESDEvent::SetPrimaryVertexTPC(const AliESDVertex *vertex)
961 // Set the TPC vertex
962 // use already allocated space
964 *fTPCVertex = *vertex;
965 fTPCVertex->SetName(fgkESDListName[kTPCVertex]);
969 void AliESDEvent::SetPrimaryVertexSPD(const AliESDVertex *vertex)
971 // Set the SPD vertex
972 // use already allocated space
974 *fSPDVertex = *vertex;
975 fSPDVertex->SetName(fgkESDListName[kSPDVertex]);
979 void AliESDEvent::SetPrimaryVertexTracks(const AliESDVertex *vertex)
981 // Set the primary vertex reconstructed using he ESD tracks.
982 // use already allocated space
984 *fPrimaryVertex = *vertex;
985 fPrimaryVertex->SetName(fgkESDListName[kPrimaryVertex]);
989 const AliESDVertex * AliESDEvent::GetPrimaryVertex() const
992 // Get the "best" available reconstructed primary vertex.
995 if (fPrimaryVertex->GetStatus()) return fPrimaryVertex;
998 if (fSPDVertex->GetStatus()) return fSPDVertex;
1000 if(fTPCVertex) return fTPCVertex;
1002 AliWarning("No primary vertex available. Returning the \"default\"...");
1006 AliESDVertex * AliESDEvent::PrimaryVertexTracksUnconstrained() const
1009 // Removes diamond constraint from fPrimaryVertex (reconstructed with tracks)
1010 // Returns a AliESDVertex which has to be deleted by the user
1012 if(!fPrimaryVertex) {
1013 AliWarning("No primary vertex from tracks available.");
1016 if(!fPrimaryVertex->GetStatus()) {
1017 AliWarning("No primary vertex from tracks available.");
1021 AliVertexerTracks vertexer(GetMagneticField());
1022 Float_t diamondxyz[3]={(Float_t)GetDiamondX(),(Float_t)GetDiamondY(),0.};
1023 Float_t diamondcovxy[3]; GetDiamondCovXY(diamondcovxy);
1024 Float_t diamondcov[6]={diamondcovxy[0],diamondcovxy[1],diamondcovxy[2],0.,0.,7.};
1025 AliESDVertex *vertex =
1026 (AliESDVertex*)vertexer.RemoveConstraintFromVertex(fPrimaryVertex,diamondxyz,diamondcov);
1031 void AliESDEvent::SetMultiplicity(const AliMultiplicity *mul)
1033 // Set the SPD Multiplicity
1040 void AliESDEvent::SetFMDData(AliESDFMD * obj)
1042 // use already allocated space
1048 void AliESDEvent::SetVZEROData(AliESDVZERO * obj)
1050 // use already allocated space
1055 void AliESDEvent::SetACORDEData(AliESDACORDE * obj)
1062 void AliESDEvent::GetESDfriend(AliESDfriend *ev) const
1065 // Extracts the complementary info from the ESD
1069 Int_t ntrk=GetNumberOfTracks();
1071 for (Int_t i=0; i<ntrk; i++) {
1072 AliESDtrack *t=GetTrack(i);
1073 const AliESDfriendTrack *f=t->GetFriendTrack();
1076 t->ReleaseESDfriendTrack();// Not to have two copies of "friendTrack"
1080 AliESDfriend *fr = (AliESDfriend*)(const_cast<AliESDEvent*>(this)->FindListObject("AliESDfriend"));
1081 if (fr) ev->SetVZEROfriend(fr->GetVZEROfriend());
1084 void AliESDEvent::AddObject(TObject* obj)
1086 // Add an object to the list of object.
1087 // Please be aware that in order to increase performance you should
1088 // refrain from using TObjArrays (if possible). Use TClonesArrays, instead.
1089 fESDObjects->SetOwner(kTRUE);
1090 fESDObjects->AddLast(obj);
1094 void AliESDEvent::GetStdContent()
1096 // set pointers for standard content
1097 // get by name much safer and not a big overhead since not called very often
1099 fESDRun = (AliESDRun*)fESDObjects->FindObject(fgkESDListName[kESDRun]);
1100 fHeader = (AliESDHeader*)fESDObjects->FindObject(fgkESDListName[kHeader]);
1101 fESDZDC = (AliESDZDC*)fESDObjects->FindObject(fgkESDListName[kESDZDC]);
1102 fESDFMD = (AliESDFMD*)fESDObjects->FindObject(fgkESDListName[kESDFMD]);
1103 fESDVZERO = (AliESDVZERO*)fESDObjects->FindObject(fgkESDListName[kESDVZERO]);
1104 fESDTZERO = (AliESDTZERO*)fESDObjects->FindObject(fgkESDListName[kESDTZERO]);
1105 fTPCVertex = (AliESDVertex*)fESDObjects->FindObject(fgkESDListName[kTPCVertex]);
1106 fSPDVertex = (AliESDVertex*)fESDObjects->FindObject(fgkESDListName[kSPDVertex]);
1107 fPrimaryVertex = (AliESDVertex*)fESDObjects->FindObject(fgkESDListName[kPrimaryVertex]);
1108 fSPDMult = (AliMultiplicity*)fESDObjects->FindObject(fgkESDListName[kSPDMult]);
1109 fPHOSTrigger = (AliESDCaloTrigger*)fESDObjects->FindObject(fgkESDListName[kPHOSTrigger]);
1110 fEMCALTrigger = (AliESDCaloTrigger*)fESDObjects->FindObject(fgkESDListName[kEMCALTrigger]);
1111 fSPDPileupVertices = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kSPDPileupVertices]);
1112 fTrkPileupVertices = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kTrkPileupVertices]);
1113 fTracks = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kTracks]);
1114 fMuonTracks = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kMuonTracks]);
1115 fPmdTracks = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kPmdTracks]);
1116 fTrdTracks = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kTrdTracks]);
1117 fV0s = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kV0s]);
1118 fCascades = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kCascades]);
1119 fKinks = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kKinks]);
1120 fCaloClusters = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kCaloClusters]);
1121 fEMCALCells = (AliESDCaloCells*)fESDObjects->FindObject(fgkESDListName[kEMCALCells]);
1122 fPHOSCells = (AliESDCaloCells*)fESDObjects->FindObject(fgkESDListName[kPHOSCells]);
1123 fErrorLogs = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kErrorLogs]);
1124 fESDACORDE = (AliESDACORDE*)fESDObjects->FindObject(fgkESDListName[kESDACORDE]);
1128 void AliESDEvent::SetStdNames(){
1129 // Set the names of the standard contents
1131 if(fESDObjects->GetEntries()>=kESDListN){
1132 for(int i = 0;i < fESDObjects->GetEntries() && i<kESDListN;i++){
1133 TObject *fObj = fESDObjects->At(i);
1134 if(fObj->InheritsFrom("TNamed")){
1135 ((TNamed*)fObj)->SetName(fgkESDListName[i]);
1137 else if(fObj->InheritsFrom("TClonesArray")){
1138 ((TClonesArray*)fObj)->SetName(fgkESDListName[i]);
1143 AliWarning("Std Entries missing");
1148 void AliESDEvent::CreateStdContent(Bool_t bUseThisList){
1149 fUseOwnList = bUseThisList;
1153 void AliESDEvent::CreateStdContent()
1155 // create the standard AOD content and set pointers
1157 // create standard objects and add them to the TList of objects
1158 AddObject(new AliESDRun());
1159 AddObject(new AliESDHeader());
1160 AddObject(new AliESDZDC());
1161 AddObject(new AliESDFMD());
1162 AddObject(new AliESDVZERO());
1163 AddObject(new AliESDTZERO());
1164 AddObject(new AliESDVertex());
1165 AddObject(new AliESDVertex());
1166 AddObject(new AliESDVertex());
1167 AddObject(new AliMultiplicity());
1168 AddObject(new AliESDCaloTrigger());
1169 AddObject(new AliESDCaloTrigger());
1170 AddObject(new TClonesArray("AliESDVertex",0));
1171 AddObject(new TClonesArray("AliESDVertex",0));
1172 AddObject(new TClonesArray("AliESDtrack",0));
1173 AddObject(new TClonesArray("AliESDMuonTrack",0));
1174 AddObject(new TClonesArray("AliESDPmdTrack",0));
1175 AddObject(new TClonesArray("AliESDTrdTrack",0));
1176 AddObject(new TClonesArray("AliESDv0",0));
1177 AddObject(new TClonesArray("AliESDcascade",0));
1178 AddObject(new TClonesArray("AliESDkink",0));
1179 AddObject(new TClonesArray("AliESDCaloCluster",0));
1180 AddObject(new AliESDCaloCells());
1181 AddObject(new AliESDCaloCells());
1182 AddObject(new TClonesArray("AliRawDataErrorLog",0));
1183 AddObject(new AliESDACORDE());
1185 // check the order of the indices against enum...
1189 // read back pointers
1193 TObject* AliESDEvent::FindListObject(const char *name){
1195 // Find object with name "name" in the list of branches
1198 return fESDObjects->FindObject(name);
1203 Int_t AliESDEvent::GetPHOSClusters(TRefArray *clusters) const
1205 // fills the provided TRefArray with all found phos clusters
1209 AliESDCaloCluster *cl = 0;
1210 for (Int_t i = 0; i < GetNumberOfCaloClusters(); i++) {
1212 if ( (cl = GetCaloCluster(i)) ) {
1215 AliDebug(1,Form("IsPHOS cluster %d Size: %d \n",i,clusters->GetEntriesFast()));
1219 return clusters->GetEntriesFast();
1222 Int_t AliESDEvent::GetEMCALClusters(TRefArray *clusters) const
1224 // fills the provided TRefArray with all found emcal clusters
1228 AliESDCaloCluster *cl = 0;
1229 for (Int_t i = 0; i < GetNumberOfCaloClusters(); i++) {
1231 if ( (cl = GetCaloCluster(i)) ) {
1234 AliDebug(1,Form("IsEMCAL cluster %d Size: %d \n",i,clusters->GetEntriesFast()));
1238 return clusters->GetEntriesFast();
1241 void AliESDEvent::WriteToTree(TTree* tree) const {
1242 // Book the branches as in TTree::Branch(TCollection*)
1243 // but add a "." at the end of top level branches which are
1244 // not a TClonesArray
1248 TIter next(fESDObjects);
1249 const Int_t kSplitlevel = 99; // default value in TTree::Branch()
1250 const Int_t kBufsize = 32000; // default value in TTree::Branch()
1253 while ((obj = next())) {
1254 branchname.Form("%s", obj->GetName());
1255 if(branchname.CompareTo("AliESDfriend")==0)branchname = "ESDfriend.";
1256 if ((kSplitlevel > 1) && !obj->InheritsFrom(TClonesArray::Class())) {
1257 if(!branchname.EndsWith("."))branchname += ".";
1259 if (!tree->FindBranch(branchname)) {
1260 tree->Bronch(branchname, obj->ClassName(), fESDObjects->GetObjectRef(obj),
1261 kBufsize, kSplitlevel - 1);
1267 void AliESDEvent::ReadFromTree(TTree *tree, Option_t* opt){
1269 // Connect the ESDEvent to a tree
1272 AliWarning("AliESDEvent::ReadFromTree() Zero Pointer to Tree \n");
1276 if(!tree->GetTree())tree->LoadTree(0);
1278 // if we find the "ESD" branch on the tree we do have the old structure
1279 if(tree->GetBranch("ESD")) {
1280 char ** address = (char **)(tree->GetBranch("ESD")->GetAddress());
1281 // do we have the friend branch
1282 TBranch * esdFB = tree->GetBranch("ESDfriend.");
1283 char ** addressF = 0;
1284 if(esdFB)addressF = (char **)(esdFB->GetAddress());
1286 AliInfo("AliESDEvent::ReadFromTree() Reading old Tree");
1287 tree->SetBranchAddress("ESD", &fESDOld);
1289 tree->SetBranchAddress("ESDfriend.",&fESDFriendOld);
1292 AliInfo("AliESDEvent::ReadFromTree() Reading old Tree");
1293 AliInfo("Branch already connected. Using existing branch address.");
1294 fESDOld = (AliESD*) (*address);
1295 // addressF can still be 0, since branch needs to switched on
1296 if(addressF)fESDFriendOld = (AliESDfriend*) (*addressF);
1299 // have already connected the old ESD structure... ?
1300 // reuse also the pointer of the AlliESDEvent
1301 // otherwise create new ones
1302 TList* connectedList = (TList*) (tree->GetUserInfo()->FindObject("ESDObjectsConnectedToTree"));
1305 // If connected use the connected list of objects
1306 if(fESDObjects!= connectedList){
1307 // protect when called twice
1308 fESDObjects->Delete();
1309 fESDObjects = connectedList;
1314 // The pointer to the friend changes when called twice via InitIO
1315 // since AliESDEvent is deleted
1316 TObject* oldf = FindListObject("AliESDfriend");
1319 newf = (TObject*)*addressF;
1321 if(newf!=0&&oldf!=newf){
1322 // remove the old reference
1323 // Should we also delete it? Or is this handled in TTree I/O
1324 // since it is created by the first SetBranchAddress
1325 fESDObjects->Remove(oldf);
1327 fESDObjects->Add(newf);
1334 CreateStdContent(); // create for copy
1335 // if we have the esdfriend add it, so we always can access it via the userinfo
1336 if(fESDFriendOld)AddObject(fESDFriendOld);
1337 // we are not owner of the list objects
1338 // must not delete it
1339 fESDObjects->SetOwner(kTRUE);
1340 fESDObjects->SetName("ESDObjectsConnectedToTree");
1341 tree->GetUserInfo()->Add(fESDObjects);
1349 // Try to find AliESDEvent
1350 AliESDEvent *esdEvent = 0;
1351 esdEvent = (AliESDEvent*)tree->GetTree()->GetUserInfo()->FindObject("AliESDEvent");
1353 // Check if already connected to tree
1355 TList* connectedList = (TList*) (tree->GetUserInfo()->FindObject("ESDObjectsConnectedToTree"));
1358 if (connectedList && (strcmp(opt, "reconnect"))) {
1359 // If connected use the connected list if objects
1360 fESDObjects->Delete();
1361 fESDObjects = connectedList;
1368 // prevent a memory leak when reading back the TList
1369 if (!(strcmp(opt, "reconnect"))) fESDObjects->Delete();
1372 // create a new TList from the UserInfo TList...
1373 // copy constructor does not work...
1374 fESDObjects = (TList*)(esdEvent->GetList()->Clone());
1375 fESDObjects->SetOwner(kTRUE);
1377 else if ( fESDObjects->GetEntries()==0){
1378 // at least create the std content if we want to read to our list
1383 // we only need new things in the list if we do no already have it..
1384 // TODO just add new entries
1386 if(fESDObjects->GetEntries()<kESDListN){
1387 AliWarning(Form("AliESDEvent::ReadFromTree() TList contains less than the standard contents %d < %d \n",
1388 fESDObjects->GetEntries(),kESDListN));
1390 // set the branch addresses
1391 TIter next(fESDObjects);
1393 while((el=(TNamed*)next())){
1394 TString bname(el->GetName());
1395 if(bname.CompareTo("AliESDfriend")==0)
1397 // AliESDfriend does not have a name ...
1398 tree->SetBranchAddress("ESDfriend.",fESDObjects->GetObjectRef(el));
1401 // check if branch exists under this Name
1402 TBranch *br = tree->GetBranch(bname.Data());
1404 tree->SetBranchAddress(bname.Data(),fESDObjects->GetObjectRef(el));
1407 br = tree->GetBranch(Form("%s.",bname.Data()));
1409 tree->SetBranchAddress(Form("%s.",bname.Data()),fESDObjects->GetObjectRef(el));
1412 AliWarning(Form("AliESDEvent::ReadFromTree() No Branch found with Name %s or %s.",bname.Data(),bname.Data()));
1419 // when reading back we are not owner of the list
1420 // must not delete it
1421 fESDObjects->SetOwner(kTRUE);
1422 fESDObjects->SetName("ESDObjectsConnectedToTree");
1423 // we are not owner of the list objects
1424 // must not delete it
1425 tree->GetUserInfo()->Add(fESDObjects);
1426 tree->GetUserInfo()->SetOwner(kFALSE);
1430 // we can't get the list from the user data, create standard content
1431 // and set it by hand (no ESDfriend at the moment
1433 TIter next(fESDObjects);
1435 while((el=(TNamed*)next())){
1436 TString bname(el->GetName());
1437 TBranch *br = tree->GetBranch(bname.Data());
1439 tree->SetBranchAddress(bname.Data(),fESDObjects->GetObjectRef(el));
1442 br = tree->GetBranch(Form("%s.",bname.Data()));
1444 tree->SetBranchAddress(Form("%s.",bname.Data()),fESDObjects->GetObjectRef(el));
1449 // when reading back we are not owner of the list
1450 // must not delete it
1451 fESDObjects->SetOwner(kTRUE);
1456 void AliESDEvent::CopyFromOldESD()
1458 // Method which copies over everthing from the old esd structure to the
1463 SetRunNumber(fESDOld->GetRunNumber());
1464 SetPeriodNumber(fESDOld->GetPeriodNumber());
1465 SetMagneticField(fESDOld->GetMagneticField());
1467 // leave out diamond ...
1468 // SetDiamond(const AliESDVertex *vertex) { fESDRun->SetDiamond(vertex);}
1471 SetTriggerMask(fESDOld->GetTriggerMask());
1472 SetOrbitNumber(fESDOld->GetOrbitNumber());
1473 SetTimeStamp(fESDOld->GetTimeStamp());
1474 SetEventType(fESDOld->GetEventType());
1475 SetEventNumberInFile(fESDOld->GetEventNumberInFile());
1476 SetBunchCrossNumber(fESDOld->GetBunchCrossNumber());
1477 SetTriggerCluster(fESDOld->GetTriggerCluster());
1481 SetZDC(fESDOld->GetZDCN1Energy(),
1482 fESDOld->GetZDCP1Energy(),
1483 fESDOld->GetZDCEMEnergy(),
1485 fESDOld->GetZDCN2Energy(),
1486 fESDOld->GetZDCP2Energy(),
1487 fESDOld->GetZDCParticipants(),
1497 if(fESDOld->GetFMDData())SetFMDData(fESDOld->GetFMDData());
1501 SetT0zVertex(fESDOld->GetT0zVertex());
1502 SetT0(fESDOld->GetT0());
1506 if (fESDOld->GetVZEROData()) SetVZEROData(fESDOld->GetVZEROData());
1508 if(fESDOld->GetVertex())SetPrimaryVertexSPD(fESDOld->GetVertex());
1510 if(fESDOld->GetPrimaryVertex())SetPrimaryVertexTracks(fESDOld->GetPrimaryVertex());
1512 if(fESDOld->GetMultiplicity())SetMultiplicity(fESDOld->GetMultiplicity());
1514 for(int i = 0;i<fESDOld->GetNumberOfTracks();i++){
1515 AddTrack(fESDOld->GetTrack(i));
1518 for(int i = 0;i<fESDOld->GetNumberOfMuonTracks();i++){
1519 AddMuonTrack(fESDOld->GetMuonTrack(i));
1522 for(int i = 0;i<fESDOld->GetNumberOfPmdTracks();i++){
1523 AddPmdTrack(fESDOld->GetPmdTrack(i));
1526 for(int i = 0;i<fESDOld->GetNumberOfTrdTracks();i++){
1527 AddTrdTrack(fESDOld->GetTrdTrack(i));
1530 for(int i = 0;i<fESDOld->GetNumberOfV0s();i++){
1531 AddV0(fESDOld->GetV0(i));
1534 for(int i = 0;i<fESDOld->GetNumberOfCascades();i++){
1535 AddCascade(fESDOld->GetCascade(i));
1538 for(int i = 0;i<fESDOld->GetNumberOfKinks();i++){
1539 AddKink(fESDOld->GetKink(i));
1543 for(int i = 0;i<fESDOld->GetNumberOfCaloClusters();i++){
1544 AddCaloCluster(fESDOld->GetCaloCluster(i));
1550 Bool_t AliESDEvent::IsEventSelected(const char *trigExpr) const
1552 // Check if the event satisfies the trigger
1553 // selection expression trigExpr.
1554 // trigExpr can be any logical expression
1555 // of the trigger classes defined in AliESDRun
1556 // In case of wrong syntax return kTRUE.
1558 TString expr(trigExpr);
1559 if (expr.IsNull()) return kTRUE;
1561 ULong64_t mask = GetTriggerMask();
1562 for(Int_t itrig = 0; itrig < AliESDRun::kNTriggerClasses; itrig++) {
1563 if (mask & (1ull << itrig)) {
1564 expr.ReplaceAll(GetESDRun()->GetTriggerClass(itrig),"1");
1567 expr.ReplaceAll(GetESDRun()->GetTriggerClass(itrig),"0");
1572 if ((gROOT->ProcessLineFast(expr.Data(),&error) == 0) &&
1573 (error == TInterpreter::kNoError)) {
1581 TObject* AliESDEvent::GetHLTTriggerDecision() const
1583 // get the HLT trigger decission object
1585 // cast away const'nes because the FindListObject method
1587 AliESDEvent* pNonConst=const_cast<AliESDEvent*>(this);
1588 return pNonConst->FindListObject("HLTGlobalTrigger");
1591 TString AliESDEvent::GetHLTTriggerDescription() const
1593 // get the HLT trigger decission description
1594 TString description;
1595 TObject* pDecision=GetHLTTriggerDecision();
1597 description=pDecision->GetTitle();
1603 Bool_t AliESDEvent::IsHLTTriggerFired(const char* name) const
1605 // get the HLT trigger decission description
1606 TObject* pDecision=GetHLTTriggerDecision();
1607 if (!pDecision) return kFALSE;
1609 Option_t* option=pDecision->GetOption();
1610 if (option==NULL || *option!='1') return kFALSE;
1613 TString description=GetHLTTriggerDescription();
1614 Int_t index=description.Index(name);
1615 if (index<0) return kFALSE;
1616 index+=strlen(name);
1617 if (index>=description.Length()) return kFALSE;
1618 if (description[index]!=0 && description[index]!=' ') return kFALSE;
1623 Bool_t AliESDEvent::IsPileupFromSPD(Int_t ncont, Double_t distz, Double_t nSigmaDeltaZ, Double_t nSigmaXY, Int_t option) const {
1625 // This function checks if there was a pile up
1626 // reconstructed with SPD
1628 Double_t diamx= GetDiamondX();
1629 Double_t diamsigma2x= GetSigma2DiamondX();
1630 Double_t diamy= GetDiamondY();
1631 Double_t diamsigma2y= GetSigma2DiamondY();
1633 Double_t sigmax= TMath::Sqrt(diamsigma2x);
1634 Double_t sigmay= TMath::Sqrt(diamsigma2y);
1636 Double_t z1=fSPDVertex->GetZ();
1637 Int_t nc1=fSPDVertex->GetNContributors();
1638 if(nc1<1) return kFALSE;
1639 Int_t nPileVert=GetNumberOfPileupVerticesSPD();
1640 if(nPileVert==0) return kFALSE;
1641 for(Int_t i=0; i<nPileVert;i++){
1642 const AliESDVertex* pv=GetPileupVertexSPD(i);
1643 Double_t z2=pv->GetZ();
1644 Double_t x2=pv->GetX();
1645 Double_t y2=pv->GetY();
1646 Int_t nc2=pv->GetNContributors();
1647 Double_t distanceZ=TMath::Abs(z2-z1);
1648 Double_t distanceX=TMath::Abs(x2-diamx);
1649 Double_t distanceY=TMath::Abs(y2-diamy);
1650 Double_t errzDist=0.;
1651 Double_t errxDist=0.;
1652 Double_t erryDist=0.;
1654 Double_t ez1=fSPDVertex->GetZRes();
1655 Double_t ez2=pv->GetZRes();
1656 errzDist=TMath::Sqrt(ez1*ez1+ez2*ez2);
1658 Double_t resol1=-75.6+834.6/TMath::Sqrt((Double_t)nc1);
1660 Double_t resol2=-75.6+834.6/TMath::Sqrt((Double_t)nc2);
1662 errzDist=TMath::Sqrt(resol1*resol1+resol2*resol2);
1666 Double_t ex2 = pv->GetXRes();
1667 Double_t ey2= pv->GetYRes();
1668 errxDist=TMath::Sqrt(ex2*ex2+sigmax*sigmax);
1669 erryDist=TMath::Sqrt(ey2*ey2+sigmay*sigmay);
1671 if(nc2>=ncont && distanceZ>nSigmaDeltaZ*errzDist && distanceX<nSigmaXY*errxDist && distanceY<nSigmaXY*erryDist && distanceZ>distz)