]> git.uio.no Git - u/mrichter/AliRoot.git/blame_incremental - STEER/AliESDEvent.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
New more general analysis implemention for particle identification and correlation...
[u/mrichter/AliRoot.git] / STEER / AliESDEvent.cxx
... / ...
CommitLineData
1/**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3 * *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
6 * *
7 * Permission to use, copy, modify and distribute this software and its *
8 * documentation strictly for non-commercial purposes is hereby granted *
9 * without fee, provided that the above copyright notice appears in all *
10 * copies and that both the copyright notice and this permission notice *
11 * appear in the supporting documentation. The authors make no claims *
12 * about the suitability of this software for any purpose. It is *
13 * provided "as is" without express or implied warranty. *
14 **************************************************************************/
15
16/* $Id$ */
17
18//-----------------------------------------------------------------
19// 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.
22/*
23 AliESDEvent *ev= new AliESDEvent();
24 ev->ReadFromTree(esdTree);
25 ...
26 for (Int_t i=0; i<nev; i++) {
27 esdTree->GetEntry(i);
28 if(ev->GetAliESDOld())ev->CopyFromOldESD();
29*/
30// The AliESDInputHandler does this automatically for you
31//
32// Origin: Christian Klein-Boesing, CERN, Christian.Klein-Boesing@cern.ch
33//-----------------------------------------------------------------
34
35#include "TList.h"
36#include "TRefArray.h"
37#include <TNamed.h>
38
39#include "AliESDEvent.h"
40#include "AliESDfriend.h"
41#include "AliESDVZERO.h"
42#include "AliESDFMD.h"
43#include "AliESD.h"
44#include "AliESDMuonTrack.h"
45#include "AliESDPmdTrack.h"
46#include "AliESDTrdTrack.h"
47#include "AliESDVertex.h"
48#include "AliESDcascade.h"
49#include "AliESDPmdTrack.h"
50#include "AliESDTrdTrack.h"
51#include "AliESDVertex.h"
52#include "AliESDcascade.h"
53#include "AliESDkink.h"
54#include "AliESDtrack.h"
55#include "AliESDHLTtrack.h"
56#include "AliESDCaloCluster.h"
57#include "AliESDCaloCells.h"
58#include "AliESDv0.h"
59#include "AliESDFMD.h"
60#include "AliESDVZERO.h"
61#include "AliMultiplicity.h"
62#include "AliRawDataErrorLog.h"
63#include "AliLog.h"
64#include "AliESDACORDE.h"
65ClassImp(AliESDEvent)
66
67
68
69// here we define the names, some classes are no TNamed, therefore the classnames
70// are the Names
71 const char* AliESDEvent::fgkESDListName[kESDListN] = {"AliESDRun",
72 "AliESDHeader",
73 "AliESDZDC",
74 "AliESDFMD",
75 "AliESDVZERO",
76 "AliESDTZERO",
77 "TPCVertex",
78 "SPDVertex",
79 "PrimaryVertex",
80 "AliMultiplicity",
81 "PHOSTrigger",
82 "EMCALTrigger",
83 "Tracks",
84 "MuonTracks",
85 "PmdTracks",
86 "TrdTracks",
87 "V0s",
88 "Cascades",
89 "Kinks",
90 "CaloClusters",
91 "EMCALCells",
92 "PHOSCells",
93 "AliRawDataErrorLogs",
94 "AliESDACORDE"};
95
96//______________________________________________________________________________
97AliESDEvent::AliESDEvent():
98 AliVEvent(),
99 fESDObjects(new TList()),
100 fESDRun(0),
101 fHeader(0),
102 fESDZDC(0),
103 fESDFMD(0),
104 fESDVZERO(0),
105 fESDTZERO(0),
106 fTPCVertex(0),
107 fSPDVertex(0),
108 fPrimaryVertex(0),
109 fSPDMult(0),
110 fPHOSTrigger(0),
111 fEMCALTrigger(0),
112 fESDACORDE(0),
113 fTracks(0),
114 fMuonTracks(0),
115 fPmdTracks(0),
116 fTrdTracks(0),
117 fV0s(0),
118 fCascades(0),
119 fKinks(0),
120 fCaloClusters(0),
121 fEMCALCells(0), fPHOSCells(0),
122 fErrorLogs(0),
123 fESDOld(0),
124 fESDFriendOld(0),
125 fConnected(kFALSE),
126 fUseOwnList(kFALSE),
127 fEMCALClusters(0),
128 fFirstEMCALCluster(-1),
129 fPHOSClusters(0),
130 fFirstPHOSCluster(-1)
131{
132}
133//______________________________________________________________________________
134AliESDEvent::AliESDEvent(const AliESDEvent& esd):
135 AliVEvent(esd),
136 fESDObjects(new TList()),
137 fESDRun(new AliESDRun(*esd.fESDRun)),
138 fHeader(new AliESDHeader(*esd.fHeader)),
139 fESDZDC(new AliESDZDC(*esd.fESDZDC)),
140 fESDFMD(new AliESDFMD(*esd.fESDFMD)),
141 fESDVZERO(new AliESDVZERO(*esd.fESDVZERO)),
142 fESDTZERO(new AliESDTZERO(*esd.fESDTZERO)),
143 fTPCVertex(new AliESDVertex(*esd.fTPCVertex)),
144 fSPDVertex(new AliESDVertex(*esd.fSPDVertex)),
145 fPrimaryVertex(new AliESDVertex(*esd.fPrimaryVertex)),
146 fSPDMult(new AliMultiplicity(*esd.fSPDMult)),
147 fPHOSTrigger(new AliESDCaloTrigger(*esd.fPHOSTrigger)),
148 fEMCALTrigger(new AliESDCaloTrigger(*esd.fEMCALTrigger)),
149 fESDACORDE(new AliESDACORDE(*esd.fESDACORDE)),
150 fTracks(new TClonesArray(*esd.fTracks)),
151 fMuonTracks(new TClonesArray(*esd.fMuonTracks)),
152 fPmdTracks(new TClonesArray(*esd.fPmdTracks)),
153 fTrdTracks(new TClonesArray(*esd.fTrdTracks)),
154 fV0s(new TClonesArray(*esd.fV0s)),
155 fCascades(new TClonesArray(*esd.fCascades)),
156 fKinks(new TClonesArray(*esd.fKinks)),
157 fCaloClusters(new TClonesArray(*esd.fCaloClusters)),
158 fEMCALCells(new AliESDCaloCells(*esd.fEMCALCells)),
159 fPHOSCells(new AliESDCaloCells(*esd.fPHOSCells)),
160 fErrorLogs(new TClonesArray(*esd.fErrorLogs)),
161 fESDOld(new AliESD(*esd.fESDOld)),
162 fESDFriendOld(new AliESDfriend(*esd.fESDFriendOld)),
163 fConnected(esd.fConnected),
164 fUseOwnList(esd.fUseOwnList),
165 fEMCALClusters(esd.fEMCALClusters),
166 fFirstEMCALCluster(esd.fFirstEMCALCluster),
167 fPHOSClusters(esd.fPHOSClusters),
168 fFirstPHOSCluster(esd.fFirstPHOSCluster)
169
170{
171 // CKB init in the constructor list and only add here ...
172 AddObject(fESDRun);
173 AddObject(fHeader);
174 AddObject(fESDZDC);
175 AddObject(fESDFMD);
176 AddObject(fESDVZERO);
177 AddObject(fESDTZERO);
178 AddObject(fTPCVertex);
179 AddObject(fSPDVertex);
180 AddObject(fPrimaryVertex);
181 AddObject(fSPDMult);
182 AddObject(fPHOSTrigger);
183 AddObject(fEMCALTrigger);
184 AddObject(fTracks);
185 AddObject(fMuonTracks);
186 AddObject(fPmdTracks);
187 AddObject(fTrdTracks);
188 AddObject(fV0s);
189 AddObject(fCascades);
190 AddObject(fKinks);
191 AddObject(fCaloClusters);
192 AddObject(fEMCALCells);
193 AddObject(fPHOSCells);
194 AddObject(fErrorLogs);
195 AddObject(fESDACORDE);
196
197 GetStdContent();
198
199}
200
201//______________________________________________________________________________
202AliESDEvent & AliESDEvent::operator=(const AliESDEvent& source) {
203
204 // Assignment operator
205
206 if(&source == this) return *this;
207 AliVEvent::operator=(source);
208
209 // This assumes that the list is already created
210 // and that the virtual void Copy(Tobject&) function
211 // is correctly implemented in the derived class
212 // otherwise only TObject::Copy() will be used
213
214
215 if((fESDObjects->GetSize()==0)&&(source.fESDObjects->GetSize()>=kESDListN)){
216 // We cover the case that we do not yet have the
217 // standard content but the source has it
218 CreateStdContent();
219 }
220
221 TIter next(source.GetList());
222 TObject *its = 0;
223 TString name;
224 while ((its = next())) {
225 name.Form("%s", its->GetName());
226 TObject *mine = fESDObjects->FindObject(name.Data());
227 if(!mine){
228 // not in this: can be added to list (to be implemented)
229 AliWarning(Form("%s:%d Could not find %s for copying \n",
230 (char*)__FILE__,__LINE__,name.Data()));
231 continue;
232 }
233
234 if(!its->InheritsFrom("TCollection")){
235 // simple objects
236 its->Copy(*mine);
237 }
238 else if(its->InheritsFrom("TClonesArray")){
239 // Create or expand the tclonesarray pointers
240 // so we can directly copy to the object
241 TClonesArray *its_tca = (TClonesArray*)its;
242 TClonesArray *mine_tca = (TClonesArray*)mine;
243
244 // this leaves the capacity of the TClonesArray the same
245 // except for a factor of 2 increase when size > capacity
246 // does not release any memory occupied by the tca
247 mine_tca->ExpandCreate(its_tca->GetEntriesFast());
248 for(int i = 0;i < its_tca->GetEntriesFast();++i){
249 // copy
250 TObject *mine_tca_obj = mine_tca->At(i);
251 TObject *its_tca_obj = its_tca->At(i);
252 // no need to delete first
253 // pointers within the class should be handled by Copy()...
254 // Can there be Empty slots?
255 its_tca_obj->Copy(*mine_tca_obj);
256 }
257 }
258 else{
259 AliWarning(Form("%s:%d cannot copy TCollection \n",
260 (char*)__FILE__,__LINE__));
261 }
262 }
263
264 fConnected = source.fConnected;
265 fUseOwnList = source.fUseOwnList;
266 fEMCALClusters = source.fEMCALClusters;
267 fFirstEMCALCluster = source.fFirstEMCALCluster;
268 fPHOSClusters = source.fPHOSClusters;
269 fFirstPHOSCluster = source.fFirstPHOSCluster;
270
271
272 return *this;
273
274}
275
276
277//______________________________________________________________________________
278AliESDEvent::~AliESDEvent()
279{
280 //
281 // Standard destructor
282 //
283
284 // everthing on the list gets deleted automatically
285
286
287 if(fESDObjects&&!fConnected)
288 {
289 delete fESDObjects;
290 fESDObjects = 0;
291 }
292
293
294}
295
296void AliESDEvent::Copy(TObject &obj) const {
297
298 // interface to TOBject::Copy
299 // Copies the content of this into obj!
300 // bascially obj = *this
301
302 if(this==&obj)return;
303 AliESDEvent *robj = dynamic_cast<AliESDEvent*>(&obj);
304 if(!robj)return; // not an AliESEvent
305 *robj = *this;
306 return;
307}
308
309//______________________________________________________________________________
310void AliESDEvent::Reset()
311{
312
313
314 // Reset the standard contents
315 ResetStdContent();
316 if(fESDOld)fESDOld->Reset();
317 // reset for the friends...
318 if(fESDFriendOld){
319 fESDFriendOld->~AliESDfriend();
320 new (fESDFriendOld) AliESDfriend();
321 }
322 // for new data we have to fetch the Pointer from the list
323 AliESDfriend *fr = (AliESDfriend*)FindListObject("AliESDfriend");
324 if(fr){
325 // delete the content
326 fr->~AliESDfriend();
327 // make a new valid ESDfriend at the same place
328 new (fr) AliESDfriend();
329 }
330
331 // call reset for user supplied data?
332}
333
334void AliESDEvent::ResetStdContent()
335{
336 // Reset the standard contents
337 if(fESDRun) fESDRun->Reset();
338 if(fHeader) fHeader->Reset();
339 if(fESDZDC) fESDZDC->Reset();
340 if(fESDFMD) {
341 fESDFMD->Clear();
342 }
343 if(fESDVZERO){
344 // reset by callin d'to /c'tor keep the pointer
345 fESDVZERO->~AliESDVZERO();
346 new (fESDVZERO) AliESDVZERO();
347 }
348 if(fESDACORDE){
349 fESDACORDE->~AliESDACORDE();
350 new (fESDACORDE) AliESDACORDE();
351 }
352 if(fESDTZERO) fESDTZERO->Reset();
353 // CKB no clear/reset implemented
354 if(fTPCVertex){
355 fTPCVertex->~AliESDVertex();
356 new (fTPCVertex) AliESDVertex();
357 fTPCVertex->SetName(fgkESDListName[kTPCVertex]);
358 }
359 if(fSPDVertex){
360 fSPDVertex->~AliESDVertex();
361 new (fSPDVertex) AliESDVertex();
362 fSPDVertex->SetName(fgkESDListName[kSPDVertex]);
363 }
364 if(fPrimaryVertex){
365 fPrimaryVertex->~AliESDVertex();
366 new (fPrimaryVertex) AliESDVertex();
367 fPrimaryVertex->SetName(fgkESDListName[kPrimaryVertex]);
368 }
369 if(fSPDMult){
370 fSPDMult->~AliMultiplicity();
371 new (fSPDMult) AliMultiplicity();
372 }
373 if(fPHOSTrigger)fPHOSTrigger->Reset();
374 if(fEMCALTrigger)fEMCALTrigger->Reset();
375 if(fTracks)fTracks->Delete();
376 if(fMuonTracks)fMuonTracks->Delete();
377 if(fPmdTracks)fPmdTracks->Delete();
378 if(fTrdTracks)fTrdTracks->Delete();
379 if(fV0s)fV0s->Delete();
380 if(fCascades)fCascades->Delete();
381 if(fKinks)fKinks->Delete();
382 if(fCaloClusters)fCaloClusters->Delete();
383 if(fPHOSCells)fPHOSCells->DeleteContainer();
384 if(fEMCALCells)fEMCALCells->DeleteContainer();
385 if(fErrorLogs) fErrorLogs->Delete();
386
387 // don't reset fconnected fConnected and the list
388
389 fEMCALClusters=0;
390 fFirstEMCALCluster=-1;
391 fPHOSClusters=0;
392 fFirstPHOSCluster=-1;
393}
394
395
396Int_t AliESDEvent::AddV0(const AliESDv0 *v) {
397 //
398 // Add V0
399 //
400 TClonesArray &fv = *fV0s;
401 Int_t idx=fV0s->GetEntriesFast();
402 new(fv[idx]) AliESDv0(*v);
403 return idx;
404}
405
406//______________________________________________________________________________
407void AliESDEvent::Print(Option_t *) const
408{
409 //
410 // Print header information of the event
411 //
412 printf("ESD run information\n");
413 printf("Event # in file %d Bunch crossing # %d Orbit # %d Period # %d Run # %d Trigger %lld Magnetic field %f \n",
414 GetEventNumberInFile(),
415 GetBunchCrossNumber(),
416 GetOrbitNumber(),
417 GetPeriodNumber(),
418 GetRunNumber(),
419 GetTriggerMask(),
420 GetMagneticField() );
421 printf("Vertex: (%.4f +- %.4f, %.4f +- %.4f, %.4f +- %.4f) cm\n",
422 fPrimaryVertex->GetXv(), fPrimaryVertex->GetXRes(),
423 fPrimaryVertex->GetYv(), fPrimaryVertex->GetYRes(),
424 fPrimaryVertex->GetZv(), fPrimaryVertex->GetZRes());
425 printf("Mean vertex in RUN: X=%.4f Y=%.4f cm\n",
426 GetDiamondX(),GetDiamondY());
427 printf("SPD Multiplicity. Number of tracklets %d \n",
428 fSPDMult->GetNumberOfTracklets());
429 printf("Number of tracks: \n");
430 printf(" charged %d\n", GetNumberOfTracks());
431 printf(" muon %d\n", GetNumberOfMuonTracks());
432 printf(" pmd %d\n", GetNumberOfPmdTracks());
433 printf(" trd %d\n", GetNumberOfTrdTracks());
434 printf(" v0 %d\n", GetNumberOfV0s());
435 printf(" cascades %d\n", GetNumberOfCascades());
436 printf(" kinks %d\n", GetNumberOfKinks());
437 if(fPHOSCells)printf(" PHOSCells %d\n", fPHOSCells->GetNumberOfCells());
438 else printf(" PHOSCells not in the Event\n");
439 if(fEMCALCells)printf(" EMCALCells %d\n", fEMCALCells->GetNumberOfCells());
440 else printf(" EMCALCells not in the Event\n");
441 printf(" CaloClusters %d\n", GetNumberOfCaloClusters());
442 printf(" phos %d\n", GetNumberOfPHOSClusters());
443 printf(" emcal %d\n", GetNumberOfEMCALClusters());
444 printf(" FMD %s\n", (fESDFMD ? "yes" : "no"));
445 printf(" VZERO %s\n", (fESDVZERO ? "yes" : "no"));
446
447 return;
448}
449
450void AliESDEvent::SetESDfriend(const AliESDfriend *ev) const {
451 //
452 // Attaches the complementary info to the ESD
453 //
454 if (!ev) return;
455
456 // to be sure that we set the tracks also
457 // in case of old esds
458 // if(fESDOld)CopyFromOldESD();
459
460 Int_t ntrk=ev->GetNumberOfTracks();
461
462 for (Int_t i=0; i<ntrk; i++) {
463 const AliESDfriendTrack *f=ev->GetTrack(i);
464 GetTrack(i)->SetFriendTrack(f);
465 }
466}
467
468Bool_t AliESDEvent::RemoveKink(Int_t rm) const {
469 // ---------------------------------------------------------
470 // Remove a kink candidate and references to it from ESD,
471 // if this candidate does not come from a reconstructed decay
472 // Not yet implemented...
473 // ---------------------------------------------------------
474 Int_t last=GetNumberOfKinks()-1;
475 if ((rm<0)||(rm>last)) return kFALSE;
476
477 return kTRUE;
478}
479
480Bool_t AliESDEvent::RemoveV0(Int_t rm) const {
481 // ---------------------------------------------------------
482 // Remove a V0 candidate and references to it from ESD,
483 // if this candidate does not come from a reconstructed decay
484 // ---------------------------------------------------------
485 Int_t last=GetNumberOfV0s()-1;
486 if ((rm<0)||(rm>last)) return kFALSE;
487
488 AliESDv0 *v0=GetV0(rm);
489 Int_t idxP=v0->GetPindex(), idxN=v0->GetNindex();
490
491 v0=GetV0(last);
492 Int_t lastIdxP=v0->GetPindex(), lastIdxN=v0->GetNindex();
493
494 Int_t used=0;
495
496 // Check if this V0 comes from a reconstructed decay
497 Int_t ncs=GetNumberOfCascades();
498 for (Int_t n=0; n<ncs; n++) {
499 AliESDcascade *cs=GetCascade(n);
500
501 Int_t csIdxP=cs->GetPindex();
502 Int_t csIdxN=cs->GetNindex();
503
504 if (idxP==csIdxP)
505 if (idxN==csIdxN) return kFALSE;
506
507 if (csIdxP==lastIdxP)
508 if (csIdxN==lastIdxN) used++;
509 }
510
511 //Replace the removed V0 with the last V0
512 TClonesArray &a=*fV0s;
513 delete a.RemoveAt(rm);
514
515 if (rm==last) return kTRUE;
516
517 //v0 is pointing to the last V0 candidate...
518 new (a[rm]) AliESDv0(*v0);
519 delete a.RemoveAt(last);
520
521 if (!used) return kTRUE;
522
523
524 // Remap the indices of the daughters of reconstructed decays
525 for (Int_t n=0; n<ncs; n++) {
526 AliESDcascade *cs=GetCascade(n);
527
528
529 Int_t csIdxP=cs->GetPindex();
530 Int_t csIdxN=cs->GetNindex();
531
532 if (csIdxP==lastIdxP)
533 if (csIdxN==lastIdxN) {
534 cs->AliESDv0::SetIndex(1,idxP);
535 cs->AliESDv0::SetIndex(0,idxN);
536 used--;
537 if (!used) return kTRUE;
538 }
539 }
540
541 return kTRUE;
542}
543
544Bool_t AliESDEvent::RemoveTrack(Int_t rm) const {
545 // ---------------------------------------------------------
546 // Remove a track and references to it from ESD,
547 // if this track does not come from a reconstructed decay
548 // ---------------------------------------------------------
549 Int_t last=GetNumberOfTracks()-1;
550 if ((rm<0)||(rm>last)) return kFALSE;
551
552 Int_t used=0;
553
554 // Check if this track comes from the reconstructed primary vertices
555 if (fTPCVertex && fTPCVertex->GetStatus()) {
556 UShort_t *primIdx=fTPCVertex->GetIndices();
557 Int_t n=fTPCVertex->GetNIndices();
558 while (n--) {
559 Int_t idx=Int_t(primIdx[n]);
560 if (rm==idx) return kFALSE;
561 if (idx==last) used++;
562 }
563 }
564 if (fPrimaryVertex && fPrimaryVertex->GetStatus()) {
565 UShort_t *primIdx=fPrimaryVertex->GetIndices();
566 Int_t n=fPrimaryVertex->GetNIndices();
567 while (n--) {
568 Int_t idx=Int_t(primIdx[n]);
569 if (rm==idx) return kFALSE;
570 if (idx==last) used++;
571 }
572 }
573
574 // Check if this track comes from a reconstructed decay
575 Int_t nv0=GetNumberOfV0s();
576 for (Int_t n=0; n<nv0; n++) {
577 AliESDv0 *v0=GetV0(n);
578
579 Int_t idx=v0->GetNindex();
580 if (rm==idx) return kFALSE;
581 if (idx==last) used++;
582
583 idx=v0->GetPindex();
584 if (rm==idx) return kFALSE;
585 if (idx==last) used++;
586 }
587
588 Int_t ncs=GetNumberOfCascades();
589 for (Int_t n=0; n<ncs; n++) {
590 AliESDcascade *cs=GetCascade(n);
591
592 Int_t idx=cs->GetIndex();
593 if (rm==idx) return kFALSE;
594 if (idx==last) used++;
595 }
596
597 Int_t nkn=GetNumberOfKinks();
598 for (Int_t n=0; n<nkn; n++) {
599 AliESDkink *kn=GetKink(n);
600
601 Int_t idx=kn->GetIndex(0);
602 if (rm==idx) return kFALSE;
603 if (idx==last) used++;
604
605 idx=kn->GetIndex(1);
606 if (rm==idx) return kFALSE;
607 if (idx==last) used++;
608 }
609
610
611 //Replace the removed track with the last track
612 TClonesArray &a=*fTracks;
613 delete a.RemoveAt(rm);
614
615 if (rm==last) return kTRUE;
616
617 AliESDtrack *t=GetTrack(last);
618 t->SetID(rm);
619 new (a[rm]) AliESDtrack(*t);
620 delete a.RemoveAt(last);
621
622
623 if (!used) return kTRUE;
624
625
626 // Remap the indices of the tracks used for the primary vertex reconstruction
627 if (fTPCVertex && fTPCVertex->GetStatus()) {
628 UShort_t *primIdx=fTPCVertex->GetIndices();
629 Int_t n=fTPCVertex->GetNIndices();
630 while (n--) {
631 Int_t idx=Int_t(primIdx[n]);
632 if (idx==last) {
633 primIdx[n]=Short_t(rm);
634 used--;
635 if (!used) return kTRUE;
636 }
637 }
638 }
639 if (fPrimaryVertex && fPrimaryVertex->GetStatus()) {
640 UShort_t *primIdx=fPrimaryVertex->GetIndices();
641 Int_t n=fPrimaryVertex->GetNIndices();
642 while (n--) {
643 Int_t idx=Int_t(primIdx[n]);
644 if (idx==last) {
645 primIdx[n]=Short_t(rm);
646 used--;
647 if (!used) return kTRUE;
648 }
649 }
650 }
651
652 // Remap the indices of the daughters of reconstructed decays
653 for (Int_t n=0; n<nv0; n++) {
654 AliESDv0 *v0=GetV0(n);
655 if (v0->GetIndex(0)==last) {
656 v0->SetIndex(0,rm);
657 used--;
658 if (!used) return kTRUE;
659 }
660 if (v0->GetIndex(1)==last) {
661 v0->SetIndex(1,rm);
662 used--;
663 if (!used) return kTRUE;
664 }
665 }
666
667 for (Int_t n=0; n<ncs; n++) {
668 AliESDcascade *cs=GetCascade(n);
669 if (cs->GetIndex()==last) {
670 cs->SetIndex(rm);
671 used--;
672 if (!used) return kTRUE;
673 }
674 }
675
676 for (Int_t n=0; n<nkn; n++) {
677 AliESDkink *kn=GetKink(n);
678 if (kn->GetIndex(0)==last) {
679 kn->SetIndex(rm,0);
680 used--;
681 if (!used) return kTRUE;
682 }
683 if (kn->GetIndex(1)==last) {
684 kn->SetIndex(rm,1);
685 used--;
686 if (!used) return kTRUE;
687 }
688 }
689
690 return kTRUE;
691}
692
693
694Bool_t AliESDEvent::Clean(Float_t *cleanPars) {
695 //
696 // Remove the data which are not needed for the physics analysis.
697 //
698 // 1) Cleaning the V0 candidates
699 // ---------------------------
700 // If the cosine of the V0 pointing angle "csp" and
701 // the DCA between the daughter tracks "dca" does not satisfy
702 // the conditions
703 //
704 // csp > cleanPars[1] + dca/cleanPars[0]*(1.- cleanPars[1])
705 //
706 // an attempt to remove this V0 candidate from ESD is made.
707 //
708 // The V0 candidate gets removed if it does not belong to any
709 // recosntructed cascade decay
710 //
711 // 12.11.2007, optimal values: cleanPars[0]=0.5, cleanPars[1]=0.999
712 //
713 // 2) Cleaning the tracks
714 // ----------------------
715 // If track's transverse parameter is larger than cleanPars[2]
716 // OR
717 // track's longitudinal parameter is larger than cleanPars[3]
718 // an attempt to remove this track from ESD is made.
719 //
720 // The track gets removed if it does not come
721 // from a reconstructed decay
722 //
723 Bool_t rc=kFALSE;
724
725 Float_t dcaMax=cleanPars[0];
726 Float_t cspMin=cleanPars[1];
727
728 Int_t nV0s=GetNumberOfV0s();
729 for (Int_t i=nV0s-1; i>=0; i--) {
730 AliESDv0 *v0=GetV0(i);
731
732 Float_t dca=v0->GetDcaV0Daughters();
733 Float_t csp=v0->GetV0CosineOfPointingAngle();
734 Float_t cspcut=cspMin + dca/dcaMax*(1.-cspMin);
735 if (csp > cspcut) continue;
736 if (RemoveV0(i)) rc=kTRUE;
737 }
738
739
740 Float_t dmax=cleanPars[2], zmax=cleanPars[3];
741
742 const AliESDVertex *vertex=GetPrimaryVertexSPD();
743 Bool_t vtxOK=vertex->GetStatus();
744
745 Int_t nTracks=GetNumberOfTracks();
746 for (Int_t i=nTracks-1; i>=0; i--) {
747 AliESDtrack *track=GetTrack(i);
748 Float_t xy,z; track->GetImpactParameters(xy,z);
749 if ((TMath::Abs(xy) > dmax) || (vtxOK && (TMath::Abs(z) > zmax))) {
750 if (RemoveTrack(i)) rc=kTRUE;
751 }
752 }
753
754 return rc;
755}
756
757Int_t AliESDEvent::AddTrack(const AliESDtrack *t)
758{
759 // Add track
760 TClonesArray &ftr = *fTracks;
761 AliESDtrack * track = new(ftr[fTracks->GetEntriesFast()])AliESDtrack(*t);
762 track->SetID(fTracks->GetEntriesFast()-1);
763 return track->GetID();
764}
765
766 void AliESDEvent::AddMuonTrack(const AliESDMuonTrack *t)
767{
768 TClonesArray &fmu = *fMuonTracks;
769 new(fmu[fMuonTracks->GetEntriesFast()]) AliESDMuonTrack(*t);
770}
771
772void AliESDEvent::AddPmdTrack(const AliESDPmdTrack *t)
773{
774 TClonesArray &fpmd = *fPmdTracks;
775 new(fpmd[fPmdTracks->GetEntriesFast()]) AliESDPmdTrack(*t);
776}
777
778void AliESDEvent::AddTrdTrack(const AliESDTrdTrack *t)
779{
780 TClonesArray &ftrd = *fTrdTracks;
781 new(ftrd[fTrdTracks->GetEntriesFast()]) AliESDTrdTrack(*t);
782}
783
784
785
786
787Int_t AliESDEvent::AddKink(const AliESDkink *c)
788{
789 // Add kink
790 TClonesArray &fk = *fKinks;
791 AliESDkink * kink = new(fk[fKinks->GetEntriesFast()]) AliESDkink(*c);
792 kink->SetID(fKinks->GetEntriesFast()); // CKB different from the other imps..
793 return fKinks->GetEntriesFast()-1;
794}
795
796
797void AliESDEvent::AddCascade(const AliESDcascade *c)
798{
799 TClonesArray &fc = *fCascades;
800 new(fc[fCascades->GetEntriesFast()]) AliESDcascade(*c);
801}
802
803
804Int_t AliESDEvent::AddCaloCluster(const AliESDCaloCluster *c)
805{
806 // Add calocluster
807 TClonesArray &fc = *fCaloClusters;
808 AliESDCaloCluster *clus = new(fc[fCaloClusters->GetEntriesFast()]) AliESDCaloCluster(*c);
809 clus->SetID(fCaloClusters->GetEntriesFast()-1);
810 return fCaloClusters->GetEntriesFast()-1;
811 }
812
813
814void AliESDEvent::AddRawDataErrorLog(const AliRawDataErrorLog *log) const {
815 TClonesArray &errlogs = *fErrorLogs;
816 new(errlogs[errlogs.GetEntriesFast()]) AliRawDataErrorLog(*log);
817}
818
819void AliESDEvent::SetPrimaryVertexTPC(const AliESDVertex *vertex)
820{
821 // Set the TPC vertex
822 // use already allocated space
823 if(fTPCVertex){
824 *fTPCVertex = *vertex;
825 fTPCVertex->SetName(fgkESDListName[kTPCVertex]);
826 }
827}
828
829void AliESDEvent::SetPrimaryVertexSPD(const AliESDVertex *vertex)
830{
831 // Set the SPD vertex
832 // use already allocated space
833 if(fSPDVertex){
834 *fSPDVertex = *vertex;
835 fSPDVertex->SetName(fgkESDListName[kSPDVertex]);
836 }
837}
838
839void AliESDEvent::SetPrimaryVertex(const AliESDVertex *vertex)
840{
841 // Set the primary vertex
842 // use already allocated space
843 if(fPrimaryVertex){
844 *fPrimaryVertex = *vertex;
845 fPrimaryVertex->SetName(fgkESDListName[kPrimaryVertex]);
846 }
847}
848
849void AliESDEvent::SetMultiplicity(const AliMultiplicity *mul)
850{
851 // Set the SPD Multiplicity
852 if(fSPDMult){
853 *fSPDMult = *mul;
854 }
855}
856
857
858void AliESDEvent::SetFMDData(AliESDFMD * obj)
859{
860 // use already allocated space
861 if(fESDFMD){
862 *fESDFMD = *obj;
863 }
864}
865
866void AliESDEvent::SetVZEROData(AliESDVZERO * obj)
867{
868 // use already allocated space
869 if(fESDVZERO)
870 *fESDVZERO = *obj;
871}
872
873void AliESDEvent::SetACORDEData(AliESDACORDE * obj)
874{
875 if(fESDACORDE)
876 *fESDACORDE = *obj;
877}
878
879
880void AliESDEvent::GetESDfriend(AliESDfriend *ev) const
881{
882 //
883 // Extracts the complementary info from the ESD
884 //
885 if (!ev) return;
886
887 Int_t ntrk=GetNumberOfTracks();
888
889 for (Int_t i=0; i<ntrk; i++) {
890 AliESDtrack *t=GetTrack(i);
891 const AliESDfriendTrack *f=t->GetFriendTrack();
892 ev->AddTrack(f);
893
894 t->ReleaseESDfriendTrack();// Not to have two copies of "friendTrack"
895
896 }
897}
898
899
900void AliESDEvent::AddObject(TObject* obj)
901{
902 // Add an object to the list of object.
903 // Please be aware that in order to increase performance you should
904 // refrain from using TObjArrays (if possible). Use TClonesArrays, instead.
905 fESDObjects->SetOwner(kTRUE);
906 fESDObjects->AddLast(obj);
907}
908
909
910void AliESDEvent::GetStdContent()
911{
912 // set pointers for standard content
913 // get by name much safer and not a big overhead since not called very often
914
915 fESDRun = (AliESDRun*)fESDObjects->FindObject(fgkESDListName[kESDRun]);
916 fHeader = (AliESDHeader*)fESDObjects->FindObject(fgkESDListName[kHeader]);
917 fESDZDC = (AliESDZDC*)fESDObjects->FindObject(fgkESDListName[kESDZDC]);
918 fESDFMD = (AliESDFMD*)fESDObjects->FindObject(fgkESDListName[kESDFMD]);
919 fESDVZERO = (AliESDVZERO*)fESDObjects->FindObject(fgkESDListName[kESDVZERO]);
920 fESDTZERO = (AliESDTZERO*)fESDObjects->FindObject(fgkESDListName[kESDTZERO]);
921 fTPCVertex = (AliESDVertex*)fESDObjects->FindObject(fgkESDListName[kTPCVertex]);
922 fSPDVertex = (AliESDVertex*)fESDObjects->FindObject(fgkESDListName[kSPDVertex]);
923 fPrimaryVertex = (AliESDVertex*)fESDObjects->FindObject(fgkESDListName[kPrimaryVertex]);
924 fSPDMult = (AliMultiplicity*)fESDObjects->FindObject(fgkESDListName[kSPDMult]);
925 fPHOSTrigger = (AliESDCaloTrigger*)fESDObjects->FindObject(fgkESDListName[kPHOSTrigger]);
926 fEMCALTrigger = (AliESDCaloTrigger*)fESDObjects->FindObject(fgkESDListName[kEMCALTrigger]);
927 fTracks = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kTracks]);
928 fMuonTracks = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kMuonTracks]);
929 fPmdTracks = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kPmdTracks]);
930 fTrdTracks = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kTrdTracks]);
931 fV0s = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kV0s]);
932 fCascades = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kCascades]);
933 fKinks = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kKinks]);
934 fCaloClusters = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kCaloClusters]);
935 fEMCALCells = (AliESDCaloCells*)fESDObjects->FindObject(fgkESDListName[kEMCALCells]);
936 fPHOSCells = (AliESDCaloCells*)fESDObjects->FindObject(fgkESDListName[kPHOSCells]);
937 fErrorLogs = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kErrorLogs]);
938 fESDACORDE = (AliESDACORDE*)fESDObjects->FindObject(fgkESDListName[kESDACORDE]);
939
940}
941
942void AliESDEvent::SetStdNames(){
943 // Set the names of the standard contents
944 //
945 if(fESDObjects->GetEntries()==kESDListN){
946 for(int i = 0;i < fESDObjects->GetEntries();i++){
947 TObject *fObj = fESDObjects->At(i);
948 if(fObj->InheritsFrom("TNamed")){
949 ((TNamed*)fObj)->SetName(fgkESDListName[i]);
950 }
951 else if(fObj->InheritsFrom("TClonesArray")){
952 ((TClonesArray*)fObj)->SetName(fgkESDListName[i]);
953 }
954 }
955 }
956 else{
957 printf("%s:%d SetStdNames() Wrong number of Std Entries \n",(char*)__FILE__,__LINE__);
958 }
959}
960
961
962void AliESDEvent::CreateStdContent(Bool_t bUseThisList){
963 fUseOwnList = bUseThisList;
964 CreateStdContent();
965}
966
967void AliESDEvent::CreateStdContent()
968{
969 // create the standard AOD content and set pointers
970
971 // create standard objects and add them to the TList of objects
972 AddObject(new AliESDRun());
973 AddObject(new AliESDHeader());
974 AddObject(new AliESDZDC());
975 AddObject(new AliESDFMD());
976 AddObject(new AliESDVZERO());
977 AddObject(new AliESDTZERO());
978 AddObject(new AliESDVertex());
979 AddObject(new AliESDVertex());
980 AddObject(new AliESDVertex());
981 AddObject(new AliMultiplicity());
982 AddObject(new AliESDCaloTrigger());
983 AddObject(new AliESDCaloTrigger());
984 AddObject(new TClonesArray("AliESDtrack",0));
985 AddObject(new TClonesArray("AliESDMuonTrack",0));
986 AddObject(new TClonesArray("AliESDPmdTrack",0));
987 AddObject(new TClonesArray("AliESDTrdTrack",0));
988 AddObject(new TClonesArray("AliESDv0",0));
989 AddObject(new TClonesArray("AliESDcascade",0));
990 AddObject(new TClonesArray("AliESDkink",0));
991 AddObject(new TClonesArray("AliESDCaloCluster",0));
992 AddObject(new AliESDCaloCells());
993 AddObject(new AliESDCaloCells());
994 AddObject(new TClonesArray("AliRawDataErrorLog",0));
995 AddObject(new AliESDACORDE());
996
997 // check the order of the indices against enum...
998
999 // set names
1000 SetStdNames();
1001 // read back pointers
1002 GetStdContent();
1003}
1004
1005TObject* AliESDEvent::FindListObject(const char *name){
1006//
1007// Find object with name "name" in the list of branches
1008//
1009 if(fESDObjects){
1010 return fESDObjects->FindObject(name);
1011 }
1012 return 0;
1013}
1014
1015Int_t AliESDEvent::GetPHOSClusters(TRefArray *clusters) const
1016{
1017 // fills the provided TRefArray with all found phos clusters
1018
1019 clusters->Clear();
1020
1021 AliESDCaloCluster *cl = 0;
1022 for (Int_t i = 0; i < GetNumberOfCaloClusters(); i++) {
1023
1024 if ( (cl = GetCaloCluster(i)) ) {
1025 if (cl->IsPHOS()){
1026 clusters->Add(cl);
1027 AliDebug(1,Form("IsPHOS cluster %d Size: %d \n",i,clusters->GetEntriesFast()));
1028 }
1029 }
1030 }
1031 return clusters->GetEntriesFast();
1032}
1033
1034Int_t AliESDEvent::GetEMCALClusters(TRefArray *clusters) const
1035{
1036 // fills the provided TRefArray with all found emcal clusters
1037
1038 clusters->Clear();
1039
1040 AliESDCaloCluster *cl = 0;
1041 for (Int_t i = 0; i < GetNumberOfCaloClusters(); i++) {
1042
1043 if ( (cl = GetCaloCluster(i)) ) {
1044 if (cl->IsEMCAL()){
1045 clusters->Add(cl);
1046 AliDebug(1,Form("IsEMCAL cluster %d Size: %d \n",i,clusters->GetEntriesFast()));
1047 }
1048 }
1049 }
1050 return clusters->GetEntriesFast();
1051}
1052
1053const void AliESDEvent::WriteToTree(TTree* tree) const {
1054 // Book the branches as in TTree::Branch(TCollection*)
1055 // but add a "." at the end of top level branches which are
1056 // not a TClonesArray
1057
1058
1059 TString branchname;
1060 TIter next(fESDObjects);
1061 const Int_t kSplitlevel = 99; // default value in TTree::Branch()
1062 const Int_t kBufsize = 32000; // default value in TTree::Branch()
1063 TObject *obj = 0;
1064
1065 while ((obj = next())) {
1066 branchname.Form("%s", obj->GetName());
1067 if ((kSplitlevel > 1) && !obj->InheritsFrom(TClonesArray::Class())) {
1068 if(!branchname.EndsWith("."))branchname += ".";
1069 }
1070 tree->Bronch(branchname, obj->ClassName(), fESDObjects->GetObjectRef(obj),
1071 kBufsize, kSplitlevel - 1);
1072 }
1073
1074}
1075
1076
1077void AliESDEvent::ReadFromTree(TTree *tree){
1078//
1079// Connect the ESDEvent to a tree
1080//
1081 if(!tree){
1082 Printf("%s %d AliESDEvent::ReadFromTree() Zero Pointer to Tree \n",(char*)__FILE__,__LINE__);
1083 return;
1084 }
1085 // load the TTree
1086 if(!tree->GetTree())tree->LoadTree(0);
1087
1088 // if we find the "ESD" branch on the tree we do have the old structure
1089 if(tree->GetBranch("ESD")) {
1090 char ** address = (char **)(tree->GetBranch("ESD")->GetAddress());
1091 // do we have the friend branch
1092 TBranch * esdFB = tree->GetBranch("ESDfriend.");
1093 char ** addressF = 0;
1094 if(esdFB)addressF = (char **)(esdFB->GetAddress());
1095 if (!address) {
1096 printf("%s %d AliESDEvent::ReadFromTree() Reading old Tree \n",(char*)__FILE__,__LINE__);
1097 tree->SetBranchAddress("ESD", &fESDOld);
1098 if(esdFB){
1099 tree->SetBranchAddress("ESDfriend.",&fESDFriendOld);
1100 }
1101 } else {
1102 printf("%s %d AliESDEvent::ReadFromTree() Reading old Tree \n",(char*)__FILE__,__LINE__);
1103 printf("%s %d Branch already connected. Using existing branch address. \n",(char*)__FILE__,__LINE__);
1104 fESDOld = (AliESD*) (*address);
1105 // addressF can still be 0, since branch needs to switched on
1106 if(addressF)fESDFriendOld = (AliESDfriend*) (*addressF);
1107 }
1108
1109 // have already connected the old ESD structure... ?
1110 // reuse also the pointer of the AlliESDEvent
1111 // otherwise create new ones
1112 TList* connectedList = (TList*) (tree->GetUserInfo()->FindObject("ESDObjectsConnectedToTree"));
1113
1114 if(connectedList){
1115 // If connected use the connected list of objects
1116 if(fESDObjects!= connectedList){
1117 // protect when called twice
1118 fESDObjects->Delete();
1119 fESDObjects = connectedList;
1120 }
1121 GetStdContent();
1122
1123
1124 // The pointer to the friend changes when called twice via InitIO
1125 // since AliESDEvent is deleted
1126 TObject* oldf = FindListObject("AliESDfriend");
1127 TObject* newf = 0;
1128 if(addressF){
1129 newf = (TObject*)*addressF;
1130 }
1131 if(newf!=0&&oldf!=newf){
1132 // remove the old reference
1133 // Should we also delete it? Or is this handled in TTree I/O
1134 // since it is created by the first SetBranchAddress
1135 fESDObjects->Remove(oldf);
1136 // add the new one
1137 fESDObjects->Add(newf);
1138 }
1139
1140 fConnected = true;
1141 return;
1142 }
1143 // else...
1144 CreateStdContent(); // create for copy
1145 // if we have the esdfriend add it, so we always can access it via the userinfo
1146 if(fESDFriendOld)AddObject(fESDFriendOld);
1147 // we are not owner of the list objects
1148 // must not delete it
1149 fESDObjects->SetOwner(kFALSE);
1150 fESDObjects->SetName("ESDObjectsConnectedToTree");
1151 tree->GetUserInfo()->Add(fESDObjects);
1152 fConnected = true;
1153 return;
1154 }
1155
1156
1157 delete fESDOld;
1158 fESDOld = 0;
1159 // Try to find AliESDEvent
1160 AliESDEvent *esdEvent = 0;
1161 esdEvent = (AliESDEvent*)tree->GetTree()->GetUserInfo()->FindObject("AliESDEvent");
1162 if(esdEvent){
1163 // Check if already connected to tree
1164 TList* connectedList = (TList*) (tree->GetUserInfo()->FindObject("ESDObjectsConnectedToTree"));
1165 if (connectedList) {
1166 // If connected use the connected list if objects
1167 fESDObjects->Delete();
1168 fESDObjects = connectedList;
1169 GetStdContent();
1170 fConnected = true;
1171 return;
1172 }
1173
1174 // Connect to tree
1175 // prevent a memory leak when reading back the TList
1176
1177 if(!fUseOwnList){
1178 delete fESDObjects;
1179 fESDObjects = 0;
1180 // create a new TList from the UserInfo TList...
1181 // copy constructor does not work...
1182 fESDObjects = (TList*)(esdEvent->GetList()->Clone());
1183 fESDObjects->SetOwner(kFALSE);
1184 }
1185 else if ( fESDObjects->GetEntries()==0){
1186 // at least create the std content if we want to read to our list
1187 CreateStdContent();
1188 }
1189
1190 // in principle
1191 // we only need new things in the list if we do no already have it..
1192 // TODO just add new entries
1193
1194 if(fESDObjects->GetEntries()<kESDListN){
1195 printf("%s %d AliESDEvent::ReadFromTree() TList contains less than the standard contents %d < %d \n",
1196 (char*)__FILE__,__LINE__,fESDObjects->GetEntries(),kESDListN);
1197 }
1198 // set the branch addresses
1199 TIter next(fESDObjects);
1200 TNamed *el;
1201 while((el=(TNamed*)next())){
1202 TString bname(el->GetName());
1203 if(bname.CompareTo("AliESDfriend")==0)
1204 {
1205 // AliESDfriend does not have a name ...
1206 tree->SetBranchAddress("ESDfriend.",fESDObjects->GetObjectRef(el));
1207 }
1208 else{
1209 // check if branch exists under this Name
1210 TBranch *br = tree->GetBranch(bname.Data());
1211 if(br){
1212 tree->SetBranchAddress(bname.Data(),fESDObjects->GetObjectRef(el));
1213 }
1214 else{
1215 br = tree->GetBranch(Form("%s.",bname.Data()));
1216 if(br){
1217 tree->SetBranchAddress(Form("%s.",bname.Data()),fESDObjects->GetObjectRef(el));
1218 }
1219 else{
1220 printf("%s %d AliESDEvent::ReadFromTree() No Branch found with Name %s or %s. \n",
1221 (char*)__FILE__,__LINE__,bname.Data(),bname.Data());
1222 }
1223
1224 }
1225 }
1226 }
1227 GetStdContent();
1228 // when reading back we are not owner of the list
1229 // must not delete it
1230 fESDObjects->SetOwner(kFALSE);
1231 fESDObjects->SetName("ESDObjectsConnectedToTree");
1232 // we are not owner of the list objects
1233 // must not delete it
1234 tree->GetUserInfo()->Add(fESDObjects);
1235 fConnected = true;
1236 }// no esdEvent
1237 else {
1238 // we can't get the list from the user data, create standard content
1239 // and set it by hand (no ESDfriend at the moment
1240 CreateStdContent();
1241 TIter next(fESDObjects);
1242 TNamed *el;
1243 while((el=(TNamed*)next())){
1244 TString bname(el->GetName());
1245 TBranch *br = tree->GetBranch(bname.Data());
1246 if(br){
1247 tree->SetBranchAddress(bname.Data(),fESDObjects->GetObjectRef(el));
1248 }
1249 else{
1250 br = tree->GetBranch(Form("%s.",bname.Data()));
1251 if(br){
1252 tree->SetBranchAddress(Form("%s.",bname.Data()),fESDObjects->GetObjectRef(el));
1253 }
1254 }
1255 }
1256 GetStdContent();
1257 // when reading back we are not owner of the list
1258 // must not delete it
1259 fESDObjects->SetOwner(kFALSE);
1260 }
1261}
1262
1263
1264void AliESDEvent::CopyFromOldESD()
1265{
1266 // Method which copies over everthing from the old esd structure to the
1267 // new
1268 if(fESDOld){
1269 ResetStdContent();
1270 // Run
1271 SetRunNumber(fESDOld->GetRunNumber());
1272 SetPeriodNumber(fESDOld->GetPeriodNumber());
1273 SetMagneticField(fESDOld->GetMagneticField());
1274
1275 // leave out diamond ...
1276 // SetDiamond(const AliESDVertex *vertex) { fESDRun->SetDiamond(vertex);}
1277
1278 // header
1279 SetTriggerMask(fESDOld->GetTriggerMask());
1280 SetOrbitNumber(fESDOld->GetOrbitNumber());
1281 SetTimeStamp(fESDOld->GetTimeStamp());
1282 SetEventType(fESDOld->GetEventType());
1283 SetEventNumberInFile(fESDOld->GetEventNumberInFile());
1284 SetBunchCrossNumber(fESDOld->GetBunchCrossNumber());
1285 SetTriggerCluster(fESDOld->GetTriggerCluster());
1286
1287 // ZDC
1288
1289 SetZDC(fESDOld->GetZDCN1Energy(),
1290 fESDOld->GetZDCP1Energy(),
1291 fESDOld->GetZDCEMEnergy(),
1292 0,
1293 fESDOld->GetZDCN2Energy(),
1294 fESDOld->GetZDCP2Energy(),
1295 fESDOld->GetZDCParticipants());
1296
1297 // FMD
1298
1299 if(fESDOld->GetFMDData())SetFMDData(fESDOld->GetFMDData());
1300
1301 // T0
1302
1303 SetT0zVertex(fESDOld->GetT0zVertex());
1304 SetT0(fESDOld->GetT0());
1305 // leave amps out
1306
1307 // VZERO
1308 if (fESDOld->GetVZEROData()) SetVZEROData(fESDOld->GetVZEROData());
1309
1310 if(fESDOld->GetVertex())SetPrimaryVertexSPD(fESDOld->GetVertex());
1311
1312 if(fESDOld->GetPrimaryVertex())SetPrimaryVertex(fESDOld->GetPrimaryVertex());
1313
1314 if(fESDOld->GetMultiplicity())SetMultiplicity(fESDOld->GetMultiplicity());
1315
1316 for(int i = 0;i<fESDOld->GetNumberOfTracks();i++){
1317 AddTrack(fESDOld->GetTrack(i));
1318 }
1319
1320 for(int i = 0;i<fESDOld->GetNumberOfMuonTracks();i++){
1321 AddMuonTrack(fESDOld->GetMuonTrack(i));
1322 }
1323
1324 for(int i = 0;i<fESDOld->GetNumberOfPmdTracks();i++){
1325 AddPmdTrack(fESDOld->GetPmdTrack(i));
1326 }
1327
1328 for(int i = 0;i<fESDOld->GetNumberOfTrdTracks();i++){
1329 AddTrdTrack(fESDOld->GetTrdTrack(i));
1330 }
1331
1332 for(int i = 0;i<fESDOld->GetNumberOfV0s();i++){
1333 AddV0(fESDOld->GetV0(i));
1334 }
1335
1336 for(int i = 0;i<fESDOld->GetNumberOfCascades();i++){
1337 AddCascade(fESDOld->GetCascade(i));
1338 }
1339
1340 for(int i = 0;i<fESDOld->GetNumberOfKinks();i++){
1341 AddKink(fESDOld->GetKink(i));
1342 }
1343
1344
1345 for(int i = 0;i<fESDOld->GetNumberOfCaloClusters();i++){
1346 AddCaloCluster(fESDOld->GetCaloCluster(i));
1347 }
1348
1349 }// if fesdold
1350}
1351
1352
1353