Fix to CopyFromOldESD() for MagField
[u/mrichter/AliRoot.git] / STEER / AliESDEvent.cxx
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 phisical analysis of data.
21 //   It also ensures the backward compatibility with the old ESD format.
22 //
23 // Origin: Christian Klein-Boesing, CERN, Christian.Klein-Boesing@cern.ch
24 //-----------------------------------------------------------------
25
26 #include "TList.h"
27 #include "TRefArray.h"
28 #include <TNamed.h>
29
30 #include "AliLog.h"
31 #include "AliESDEvent.h"
32 #include "AliESDfriend.h"
33 #include "AliESDVZERO.h"
34 #include "AliESDHLTtrack.h"
35 #include "AliESDFMD.h"
36 #include "AliESD.h"
37 #include "AliESDMuonTrack.h"
38 #include "AliESDPmdTrack.h"
39 #include "AliESDTrdTrack.h"
40 #include "AliESDVertex.h"
41 #include "AliESDcascade.h"
42 #include "AliESDPmdTrack.h"
43 #include "AliESDTrdTrack.h"
44 #include "AliESDVertex.h"
45 #include "AliESDcascade.h"
46 #include "AliESDkink.h"
47 #include "AliESDtrack.h"
48 #include "AliESDHLTtrack.h"
49 #include "AliESDCaloCluster.h"
50 #include "AliESDv0.h"
51 #include "AliESDFMD.h"
52 #include "AliESDVZERO.h"
53 #include "AliMultiplicity.h"
54 #include "AliRawDataErrorLog.h"
55
56
57 ClassImp(AliESDEvent)
58
59
60
61 // here we define the names, some classes are no TNamed, therefore the classnames 
62 // are the Names
63   const char* AliESDEvent::fESDListName[kESDListN] = {"AliESDRun",
64                                                        "AliESDHeader",
65                                                        "AliESDZDC",
66                                                        "AliESDFMD",
67                                                        "AliESDVZERO",
68                                                        "AliESDTZERO",
69                                                        "SPDVertex",
70                                                        "PrimaryVertex",
71                                                        "AliMultiplicity",
72                                                        "PHOSTrigger",
73                                                        "EMCALTrigger",
74                                                        "Tracks",
75                                                        "MuonTracks",
76                                                        "PmdTracks",
77                                                        "TrdTracks",
78                                                        "V0s",
79                                                        "Cascades",
80                                                        "Kinks",
81                                                        "CaloClusters",
82                                                        "AliRawDataErrorLogs"};
83 //______________________________________________________________________________
84 AliESDEvent::AliESDEvent():
85   AliVEvent(),
86   fESDObjects(new TList()),
87   fESDRun(0),
88   fHeader(0),
89   fESDZDC(0),
90   fESDFMD(0),
91   fESDVZERO(0),
92   fESDTZERO(0),
93   fSPDVertex(0),
94   fPrimaryVertex(0),
95   fSPDMult(0),
96   fPHOSTrigger(0),
97   fEMCALTrigger(0),
98   fTracks(0),
99   fMuonTracks(0),
100   fPmdTracks(0),
101   fTrdTracks(0),
102   fV0s(0),  
103   fCascades(0),
104   fKinks(0),
105   fCaloClusters(0),
106   fErrorLogs(0),
107   fESDOld(0),
108   fConnected(kFALSE),
109   fEMCALClusters(0), 
110   fFirstEMCALCluster(-1),
111   fPHOSClusters(0), 
112   fFirstPHOSCluster(-1)
113 {
114 }
115 //______________________________________________________________________________
116 AliESDEvent::AliESDEvent(const AliESDEvent& esd):
117   AliVEvent(esd),
118   fESDObjects(new TList()),
119   fESDRun(new AliESDRun(*esd.fESDRun)),
120   fHeader(new AliESDHeader(*esd.fHeader)),
121   fESDZDC(new AliESDZDC(*esd.fESDZDC)),
122   fESDFMD(new AliESDFMD(*esd.fESDFMD)),
123   fESDVZERO(new AliESDVZERO(*esd.fESDVZERO)),
124   fESDTZERO(new AliESDTZERO(*esd.fESDTZERO)),
125   fSPDVertex(new AliESDVertex(*esd.fSPDVertex)),
126   fPrimaryVertex(new AliESDVertex(*esd.fPrimaryVertex)),
127   fSPDMult(new AliMultiplicity(*esd.fSPDMult)),
128   fPHOSTrigger(new AliESDCaloTrigger(*esd.fPHOSTrigger)),
129   fEMCALTrigger(new AliESDCaloTrigger(*esd.fEMCALTrigger)),
130   fTracks(new TClonesArray(*esd.fTracks)),
131   fMuonTracks(new TClonesArray(*esd.fMuonTracks)),
132   fPmdTracks(new TClonesArray(*esd.fPmdTracks)),
133   fTrdTracks(new TClonesArray(*esd.fTrdTracks)),
134   fV0s(new TClonesArray(*esd.fV0s)),  
135   fCascades(new TClonesArray(*esd.fCascades)),
136   fKinks(new TClonesArray(*esd.fKinks)),
137   fCaloClusters(new TClonesArray(*esd.fCaloClusters)),
138   fErrorLogs(new TClonesArray(*esd.fErrorLogs)),
139   fESDOld(new AliESD(*esd.fESDOld)),
140   fConnected(esd.fConnected),
141   fEMCALClusters(esd.fEMCALClusters), 
142   fFirstEMCALCluster(esd.fFirstEMCALCluster),
143   fPHOSClusters(esd.fPHOSClusters), 
144   fFirstPHOSCluster(esd.fFirstPHOSCluster)
145
146 {
147   // CKB init in the constructor list and only add here ...
148   AddObject(fESDRun);
149   AddObject(fHeader);
150   AddObject(fESDZDC);
151   AddObject(fESDFMD);
152   AddObject(fESDVZERO);
153   AddObject(fESDTZERO);
154   AddObject(fSPDVertex);
155   AddObject(fPrimaryVertex);
156   AddObject(fSPDMult);
157   AddObject(fPHOSTrigger);
158   AddObject(fEMCALTrigger);
159   AddObject(fTracks);
160   AddObject(fMuonTracks);
161   AddObject(fPmdTracks);
162   AddObject(fTrdTracks);
163   AddObject(fV0s);
164   AddObject(fCascades);
165   AddObject(fKinks);
166   AddObject(fCaloClusters);
167   AddObject(fErrorLogs);
168
169   GetStdContent();
170
171 }
172
173 //______________________________________________________________________________
174 AliESDEvent & AliESDEvent::operator=(const AliESDEvent& source) {
175
176   // Assignment operator
177
178   if(&source == this) return *this;
179   AliVEvent::operator=(source);
180
181   fESDRun = new AliESDRun(*source.fESDRun);
182   fHeader = new AliESDHeader(*source.fHeader);
183   fESDZDC = new AliESDZDC(*source.fESDZDC);
184   fESDFMD = new AliESDFMD(*source.fESDFMD);
185   fESDVZERO = new AliESDVZERO(*source.fESDVZERO);
186   fESDTZERO = new AliESDTZERO(*source.fESDTZERO);
187   fSPDVertex = new AliESDVertex(*source.fSPDVertex);
188   fPrimaryVertex = new AliESDVertex(*source.fPrimaryVertex);
189   fSPDMult = new AliMultiplicity(*source.fSPDMult);
190   fPHOSTrigger = new AliESDCaloTrigger(*source.fPHOSTrigger);
191   fEMCALTrigger = new AliESDCaloTrigger(*source.fEMCALTrigger);
192   fTracks = new TClonesArray(*source.fTracks);
193   fMuonTracks = new TClonesArray(*source.fMuonTracks);
194   fPmdTracks = new TClonesArray(*source.fPmdTracks);
195   fTrdTracks = new TClonesArray(*source.fTrdTracks);
196   fV0s = new TClonesArray(*source.fV0s);
197   fCascades = new TClonesArray(*source.fCascades);
198   fKinks = new TClonesArray(*source.fKinks);
199   fCaloClusters = new TClonesArray(*source.fCaloClusters);
200   fErrorLogs = new TClonesArray(*source.fErrorLogs);
201   fESDOld = new AliESD(*source.fESDOld);
202   // CKB this way?? or 
203   // or AddObject(  fESDZDC = new AliESDZDC(*source.fESDZDC));
204
205   fESDObjects = new TList();
206   AddObject(fESDRun);
207   AddObject(fHeader);
208   AddObject(fESDZDC);
209   AddObject(fESDFMD);
210   AddObject(fESDVZERO);
211   AddObject(fESDTZERO);
212   AddObject(fSPDVertex);
213   AddObject(fPrimaryVertex);
214   AddObject(fSPDMult);
215   AddObject(fPHOSTrigger);
216   AddObject(fEMCALTrigger);
217   AddObject(fTracks);
218   AddObject(fMuonTracks);
219   AddObject(fPmdTracks);
220   AddObject(fTrdTracks);
221   AddObject(fV0s);
222   AddObject(fCascades);
223   AddObject(fKinks);
224   AddObject(fCaloClusters);
225   AddObject(fErrorLogs);
226
227   fConnected = source.fConnected;
228   fEMCALClusters = source.fEMCALClusters;
229   fFirstEMCALCluster = source.fFirstEMCALCluster;
230   fPHOSClusters = source.fPHOSClusters;
231   fFirstPHOSCluster = source.fFirstPHOSCluster;
232
233
234
235   return *this;
236
237 }
238
239
240 //______________________________________________________________________________
241 AliESDEvent::~AliESDEvent()
242 {
243   //
244   // Standard destructor
245   //
246
247   // everthing on the list gets deleted automatically
248
249   
250   if(fESDObjects&&!fConnected)
251     {
252       delete fESDObjects;
253       fESDObjects = 0;
254     }
255
256   
257 }
258
259 //______________________________________________________________________________
260 void AliESDEvent::Reset()
261 {
262
263   
264   // Reset the standard contents
265   ResetStdContent(); 
266
267   if(fESDOld)fESDOld->Reset();
268   // call reset for user supplied data?
269 }
270
271 void AliESDEvent::ResetStdContent()
272 {
273   // Reset the standard contents
274   if(fESDRun) fESDRun->Reset();
275   if(fHeader) fHeader->Reset();
276   if(fESDZDC) fESDZDC->Reset();
277   if(fESDFMD) fESDFMD->Clear(); // why clear.... need consistend names
278   // if(fESDVZERO) fESDVZERO->; // NOT IMPLEMENTED 
279   //  if(fESDVZERO) new (fESDVZERO) AliESDVZERO();
280   if(fESDTZERO) fESDTZERO->Reset(); 
281   // CKB no clear/reset implemented
282   if(fSPDVertex){
283     fSPDVertex->~AliESDVertex();
284     new (fSPDVertex) AliESDVertex();
285     fSPDVertex->SetName(fESDListName[kSPDVertex]);
286   }
287   if(fPrimaryVertex){
288     fPrimaryVertex->~AliESDVertex();
289     new (fPrimaryVertex) AliESDVertex();
290     fPrimaryVertex->SetName(fESDListName[kPrimaryVertex]);
291   }
292   if(fSPDMult){
293     fSPDMult->~AliMultiplicity();
294     new (fSPDMult) AliMultiplicity();
295   }
296   if(fPHOSTrigger)fPHOSTrigger->Reset(); 
297   if(fEMCALTrigger)fEMCALTrigger->Reset(); 
298   if(fTracks)fTracks->Delete();
299   if(fMuonTracks)fMuonTracks->Clear();
300   if(fPmdTracks)fPmdTracks->Clear();
301   if(fTrdTracks)fTrdTracks->Clear();
302   if(fV0s)fV0s->Clear();
303   if(fCascades)fCascades->Clear();
304   if(fKinks)fKinks->Clear();
305   if(fCaloClusters)fCaloClusters->Delete();
306   if(fErrorLogs) fErrorLogs->Delete();
307
308   // don't reset fconnected fConnected ;
309
310   fEMCALClusters=0; 
311   fFirstEMCALCluster=-1; 
312   fPHOSClusters=0; 
313   fFirstPHOSCluster=-1; 
314 }
315
316
317 Int_t AliESDEvent::AddV0(const AliESDv0 *v) {
318   //
319   // Add V0
320   //
321   TClonesArray &fv = *fV0s;
322   Int_t idx=fV0s->GetEntriesFast();
323   new(fv[idx]) AliESDv0(*v);
324   return idx;
325 }  
326
327 //______________________________________________________________________________
328 void AliESDEvent::Print(Option_t *) const 
329 {
330   //
331   // Print header information of the event
332   //
333   printf("ESD run information\n");
334   printf("Event # in file %d Bunch crossing # %d Orbit # %d Period # %d Run # %d Trigger %lld Magnetic field %f \n",
335          GetEventNumberInFile(),
336          GetBunchCrossNumber(),
337          GetOrbitNumber(),
338          GetPeriodNumber(),
339          GetRunNumber(),
340          GetTriggerMask(),
341          GetMagneticField() );
342   printf("Vertex: (%.4f +- %.4f, %.4f +- %.4f, %.4f +- %.4f) cm\n",
343            fPrimaryVertex->GetXv(), fPrimaryVertex->GetXRes(),
344            fPrimaryVertex->GetYv(), fPrimaryVertex->GetYRes(),
345            fPrimaryVertex->GetZv(), fPrimaryVertex->GetZRes());
346     printf("Mean vertex in RUN: X=%.4f Y=%.4f cm\n",
347            GetDiamondX(),GetDiamondY());
348     printf("SPD Multiplicity. Number of tracklets %d \n",
349            fSPDMult->GetNumberOfTracklets());
350   printf("Number of tracks: \n");
351   printf("                 charged   %d\n", GetNumberOfTracks());
352   printf("                 muon      %d\n", GetNumberOfMuonTracks());
353   printf("                 pmd       %d\n", GetNumberOfPmdTracks());
354   printf("                 trd       %d\n", GetNumberOfTrdTracks());
355   printf("                 v0        %d\n", GetNumberOfV0s());
356   printf("                 cascades  %d\n", GetNumberOfCascades());
357   printf("                 kinks     %d\n", GetNumberOfKinks());
358   printf("                 CaloClusters %d\n", GetNumberOfCaloClusters());
359   printf("                 phos      %d\n", GetNumberOfPHOSClusters());
360   printf("                 emcal     %d\n", GetNumberOfEMCALClusters());
361   printf("                 FMD       %s\n", (fESDFMD ? "yes" : "no"));
362   printf("                 VZERO     %s\n", (fESDVZERO ? "yes" : "no"));
363
364   return;
365 }
366
367 void AliESDEvent::SetESDfriend(const AliESDfriend *ev) {
368   //
369   // Attaches the complementary info to the ESD
370   //
371   if (!ev) return;
372
373   // to be sure that we set the tracks also
374   // in case of old esds 
375   // if(fESDOld)CopyFromOldESD();
376
377   Int_t ntrk=ev->GetNumberOfTracks();
378  
379   for (Int_t i=0; i<ntrk; i++) {
380     const AliESDfriendTrack *f=ev->GetTrack(i);
381     GetTrack(i)->SetFriendTrack(f);
382   }
383 }
384
385 Bool_t  AliESDEvent::RemoveKink(Int_t rm) {
386   // ---------------------------------------------------------
387   // Remove a kink candidate and references to it from ESD,
388   // if this candidate does not come from a reconstructed decay
389   // Not yet implemented...
390   // ---------------------------------------------------------
391   Int_t last=GetNumberOfKinks()-1;
392   if ((rm<0)||(rm>last)) return kFALSE;
393
394   return kTRUE;
395 }
396
397 Bool_t  AliESDEvent::RemoveV0(Int_t rm) {
398   // ---------------------------------------------------------
399   // Remove a V0 candidate and references to it from ESD,
400   // if this candidate does not come from a reconstructed decay
401   // ---------------------------------------------------------
402   Int_t last=GetNumberOfV0s()-1;
403   if ((rm<0)||(rm>last)) return kFALSE;
404
405   AliESDv0 *v0=GetV0(rm);
406   Int_t idxP=v0->GetPindex(), idxN=v0->GetNindex();
407
408   v0=GetV0(last);
409   Int_t lastIdxP=v0->GetPindex(), lastIdxN=v0->GetNindex();
410
411   Int_t used=0;
412
413   // Check if this V0 comes from a reconstructed decay
414   Int_t ncs=GetNumberOfCascades();
415   for (Int_t n=0; n<ncs; n++) {
416     AliESDcascade *cs=GetCascade(n);
417
418     Int_t csIdxP=cs->GetPindex();
419     Int_t csIdxN=cs->GetNindex();
420
421     if (idxP==csIdxP)
422        if (idxN==csIdxN) return kFALSE;
423
424     if (csIdxP==lastIdxP)
425        if (csIdxN==lastIdxN) used++;
426   }
427
428   //Replace the removed V0 with the last V0 
429   TClonesArray &a=*fV0s;
430   delete a.RemoveAt(rm);
431
432   if (rm==last) return kTRUE;
433
434   //v0 is pointing to the last V0 candidate... 
435   new (a[rm]) AliESDv0(*v0);
436   delete a.RemoveAt(last);
437
438   if (!used) return kTRUE;
439   
440
441   // Remap the indices of the daughters of reconstructed decays
442   for (Int_t n=0; n<ncs; n++) {
443     AliESDcascade *cs=GetCascade(n);
444
445
446     Int_t csIdxP=cs->GetPindex();
447     Int_t csIdxN=cs->GetNindex();
448
449     if (csIdxP==lastIdxP)
450       if (csIdxN==lastIdxN) {
451          cs->AliESDv0::SetIndex(1,idxP);
452          cs->AliESDv0::SetIndex(0,idxN);
453          used--;
454          if (!used) return kTRUE;
455       }
456   }
457
458   return kTRUE;
459 }
460
461 Bool_t  AliESDEvent::RemoveTrack(Int_t rm) {
462   // ---------------------------------------------------------
463   // Remove a track and references to it from ESD,
464   // if this track does not come from a reconstructed decay
465   // ---------------------------------------------------------
466   Int_t last=GetNumberOfTracks()-1;
467   if ((rm<0)||(rm>last)) return kFALSE;
468
469   Int_t used=0;
470
471   // Check if this track comes from a reconstructed decay
472   Int_t nv0=GetNumberOfV0s();
473   for (Int_t n=0; n<nv0; n++) {
474     AliESDv0 *v0=GetV0(n);
475
476     Int_t idx=v0->GetNindex();
477     if (rm==idx) return kFALSE;
478     if (idx==last) used++;
479
480     idx=v0->GetPindex();
481     if (rm==idx) return kFALSE;
482     if (idx==last) used++;
483   }
484
485   Int_t ncs=GetNumberOfCascades();
486   for (Int_t n=0; n<ncs; n++) {
487     AliESDcascade *cs=GetCascade(n);
488
489     Int_t idx=cs->GetIndex();
490     if (rm==idx) return kFALSE;
491     if (idx==last) used++;
492   }
493
494   Int_t nkn=GetNumberOfKinks();
495   for (Int_t n=0; n<nkn; n++) {
496     AliESDkink *kn=GetKink(n);
497
498     Int_t idx=kn->GetIndex(0);
499     if (rm==idx) return kFALSE;
500     if (idx==last) used++;
501
502     idx=kn->GetIndex(1);
503     if (rm==idx) return kFALSE;
504     if (idx==last) used++;
505   }
506
507
508   //Replace the removed track with the last track 
509   TClonesArray &a=*fTracks;
510   delete a.RemoveAt(rm);
511
512   if (rm==last) return kTRUE;
513
514   AliESDtrack *t=GetTrack(last);
515   t->SetID(rm);
516   new (a[rm]) AliESDtrack(*t);
517   delete a.RemoveAt(last);
518
519   if (!used) return kTRUE;
520   
521
522   // Remap the indices of the daughters of reconstructed decays
523   for (Int_t n=0; n<nv0; n++) {
524     AliESDv0 *v0=GetV0(n);
525     if (v0->GetIndex(0)==last) {
526        v0->SetIndex(0,rm);
527        used--;
528        if (!used) return kTRUE;
529     }
530     if (v0->GetIndex(1)==last) {
531        v0->SetIndex(1,rm);
532        used--;
533        if (!used) return kTRUE;
534     }
535   }
536
537   for (Int_t n=0; n<ncs; n++) {
538     AliESDcascade *cs=GetCascade(n);
539     if (cs->GetIndex()==last) {
540        cs->SetIndex(rm);
541        used--;
542        if (!used) return kTRUE;
543     }
544   }
545
546   for (Int_t n=0; n<nkn; n++) {
547     AliESDkink *kn=GetKink(n);
548     if (kn->GetIndex(0)==last) {
549        kn->SetIndex(rm,0);
550        used--;
551        if (!used) return kTRUE;
552     }
553     if (kn->GetIndex(1)==last) {
554        kn->SetIndex(rm,1);
555        used--;
556        if (!used) return kTRUE;
557     }
558   }
559
560   return kTRUE;
561 }
562
563
564 Bool_t AliESDEvent::Clean(Float_t *cleanPars) {
565   //
566   // Remove the data which are not needed for the physics analysis.
567   //
568   // 1) Cleaning the V0 candidates
569   //    ---------------------------
570   //    If the cosine of the V0 pointing angle "csp" and 
571   //    the DCA between the daughter tracks "dca" does not satisfy 
572   //    the conditions 
573   //
574   //     csp > cleanPars[1] + dca/cleanPars[0]*(1.- cleanPars[1])
575   //
576   //    an attempt to remove this V0 candidate from ESD is made.
577   //
578   //    The V0 candidate gets removed if it does not belong to any 
579   //    recosntructed cascade decay
580   //
581   //    12.11.2007, optimal values: cleanPars[0]=0.5, cleanPars[1]=0.999
582   //
583   // 2) Cleaning the tracks
584   //    ----------------------
585   //    If track's transverse parameter is larger than cleanPars[2]
586   //                       OR
587   //    track's longitudinal parameter is larger than cleanPars[3]
588   //    an attempt to remove this track from ESD is made.
589   //
590   //    The track gets removed if it does not come 
591   //    from a reconstructed decay
592   //
593   Bool_t rc=kFALSE;
594
595   Float_t dcaMax=cleanPars[0];
596   Float_t cspMin=cleanPars[1];
597
598   Int_t nV0s=GetNumberOfV0s();
599   for (Int_t i=nV0s-1; i>=0; i--) {
600     AliESDv0 *v0=GetV0(i);
601
602     Float_t dca=v0->GetDcaV0Daughters();
603     Float_t csp=v0->GetV0CosineOfPointingAngle();
604     Float_t cspcut=cspMin + dca/dcaMax*(1.-cspMin);
605     if (csp > cspcut) continue;
606
607     if (RemoveV0(i)) rc=kTRUE;
608   }
609
610
611   Float_t dmax=cleanPars[2], zmax=cleanPars[3];
612
613   const AliESDVertex *vertex=GetVertex();
614   Bool_t vtxOK=vertex->GetStatus();
615   
616   Int_t nTracks=GetNumberOfTracks();
617   for (Int_t i=nTracks-1; i>=0; i--) {
618     AliESDtrack *track=GetTrack(i);
619     Float_t xy,z; track->GetImpactParameters(xy,z);
620     if ((TMath::Abs(xy) > dmax) || (vtxOK && (TMath::Abs(z) > zmax))) {
621       if (RemoveTrack(i)) rc=kTRUE;
622     }
623   }
624
625   return rc;
626 }
627
628 Int_t  AliESDEvent::AddTrack(const AliESDtrack *t) {
629     // Add track
630     TClonesArray &ftr = *fTracks;
631     AliESDtrack * track = new(ftr[fTracks->GetEntriesFast()])AliESDtrack(*t);
632     track->SetID(fTracks->GetEntriesFast()-1);
633     return  track->GetID();    
634 }
635
636  void AliESDEvent::AddMuonTrack(const AliESDMuonTrack *t) {
637     TClonesArray &fmu = *fMuonTracks;
638     new(fmu[fMuonTracks->GetEntriesFast()]) AliESDMuonTrack(*t);
639 }
640
641 void AliESDEvent::AddPmdTrack(const AliESDPmdTrack *t) {
642   TClonesArray &fpmd = *fPmdTracks;
643   new(fpmd[fPmdTracks->GetEntriesFast()]) AliESDPmdTrack(*t);
644 }
645
646 void AliESDEvent::AddTrdTrack(const AliESDTrdTrack *t) {
647   TClonesArray &ftrd = *fTrdTracks;
648   new(ftrd[fTrdTracks->GetEntriesFast()]) AliESDTrdTrack(*t);
649 }
650
651
652
653
654 Int_t AliESDEvent::AddKink(const AliESDkink *c) {
655     // Add kink
656     TClonesArray &fk = *fKinks;
657     AliESDkink * kink = new(fk[fKinks->GetEntriesFast()]) AliESDkink(*c);
658     kink->SetID(fKinks->GetEntriesFast()); // CKB different from the other imps..
659     return fKinks->GetEntriesFast()-1;
660 }
661
662
663 void AliESDEvent::AddCascade(const AliESDcascade *c) {
664   TClonesArray &fc = *fCascades;
665   new(fc[fCascades->GetEntriesFast()]) AliESDcascade(*c);
666 }
667
668
669 Int_t AliESDEvent::AddCaloCluster(const AliESDCaloCluster *c) {
670     // Add calocluster
671     TClonesArray &fc = *fCaloClusters;
672     AliESDCaloCluster *clus = new(fc[fCaloClusters->GetEntriesFast()]) AliESDCaloCluster(*c);
673     clus->SetID(fCaloClusters->GetEntriesFast()-1);
674     return fCaloClusters->GetEntriesFast()-1;
675   }
676
677
678   void  AliESDEvent::AddRawDataErrorLog(const AliRawDataErrorLog *log) {
679     TClonesArray &errlogs = *fErrorLogs;
680     new(errlogs[errlogs.GetEntriesFast()])  AliRawDataErrorLog(*log);
681   }
682
683 void  AliESDEvent::SetVertex(const AliESDVertex *vertex) {
684   // use already allocated space
685   if(fSPDVertex){
686     *fSPDVertex = *vertex;
687     fSPDVertex->SetName(fESDListName[kSPDVertex]);
688   }
689 }
690
691 void  AliESDEvent::SetPrimaryVertex(const AliESDVertex *vertex) {
692   if(fPrimaryVertex){
693     *fPrimaryVertex = *vertex;
694     fPrimaryVertex->SetName(fESDListName[kPrimaryVertex]);
695   }
696 }
697
698 void AliESDEvent::SetMultiplicity(const AliMultiplicity *mul) {
699   if(fSPDMult){
700     *fSPDMult = *mul;
701   }
702 }
703
704
705 void AliESDEvent::SetFMDData(AliESDFMD * obj) { 
706   // use already allocated space
707   if(fESDFMD){
708     *fESDFMD = *obj;
709   }
710 }
711
712 void AliESDEvent::SetVZEROData(AliESDVZERO * obj){ 
713   // use already allocated space
714   if(fESDVZERO)
715     new(fESDVZERO) AliESDVZERO(*obj);
716 }
717
718 void AliESDEvent::GetESDfriend(AliESDfriend *ev) const {
719   //
720   // Extracts the complementary info from the ESD
721   //
722   if (!ev) return;
723
724   Int_t ntrk=GetNumberOfTracks();
725
726   for (Int_t i=0; i<ntrk; i++) {
727     AliESDtrack *t=GetTrack(i);
728     const AliESDfriendTrack *f=t->GetFriendTrack();
729     ev->AddTrack(f);
730
731     t->ReleaseESDfriendTrack();// Not to have two copies of "friendTrack"
732
733   }
734 }
735
736
737 void AliESDEvent::AddObject(TObject* obj) 
738 {
739   // Add an object to the list of object.
740   // Please be aware that in order to increase performance you should
741   // refrain from using TObjArrays (if possible). Use TClonesArrays, instead.
742   fESDObjects->SetOwner(kTRUE);
743   fESDObjects->AddLast(obj);
744 }
745
746
747 void AliESDEvent::GetStdContent() 
748 {
749   // set pointers for standard content
750   // get by name much safer and not a big overhead since not called very often
751  
752   fESDRun = (AliESDRun*)fESDObjects->FindObject(fESDListName[kESDRun]);
753   fHeader = (AliESDHeader*)fESDObjects->FindObject(fESDListName[kHeader]);
754   fESDZDC = (AliESDZDC*)fESDObjects->FindObject(fESDListName[kESDZDC]);
755   fESDFMD = (AliESDFMD*)fESDObjects->FindObject(fESDListName[kESDFMD]);
756   fESDVZERO = (AliESDVZERO*)fESDObjects->FindObject(fESDListName[kESDVZERO]);
757   fESDTZERO = (AliESDTZERO*)fESDObjects->FindObject(fESDListName[kESDTZERO]);
758   fSPDVertex = (AliESDVertex*)fESDObjects->FindObject(fESDListName[kSPDVertex]);
759   fPrimaryVertex = (AliESDVertex*)fESDObjects->FindObject(fESDListName[kPrimaryVertex]);
760   fSPDMult =       (AliMultiplicity*)fESDObjects->FindObject(fESDListName[kSPDMult]);
761   fPHOSTrigger = (AliESDCaloTrigger*)fESDObjects->FindObject(fESDListName[kPHOSTrigger]);
762   fEMCALTrigger = (AliESDCaloTrigger*)fESDObjects->FindObject(fESDListName[kEMCALTrigger]);
763   fTracks = (TClonesArray*)fESDObjects->FindObject(fESDListName[kTracks]);
764   fMuonTracks = (TClonesArray*)fESDObjects->FindObject(fESDListName[kMuonTracks]);
765   fPmdTracks = (TClonesArray*)fESDObjects->FindObject(fESDListName[kPmdTracks]);
766   fTrdTracks = (TClonesArray*)fESDObjects->FindObject(fESDListName[kTrdTracks]);
767   fV0s = (TClonesArray*)fESDObjects->FindObject(fESDListName[kV0s]);
768   fCascades = (TClonesArray*)fESDObjects->FindObject(fESDListName[kCascades]);
769   fKinks = (TClonesArray*)fESDObjects->FindObject(fESDListName[kKinks]);
770   fCaloClusters = (TClonesArray*)fESDObjects->FindObject(fESDListName[kCaloClusters]);
771   fErrorLogs = (TClonesArray*)fESDObjects->FindObject(fESDListName[kErrorLogs]);
772
773 }
774
775 void AliESDEvent::SetStdNames(){
776   // Set the names of the standard contents
777   // 
778   if(fESDObjects->GetEntries()==kESDListN){
779     for(int i = 0;i < fESDObjects->GetEntries();i++){
780       TObject *fObj = fESDObjects->At(i);
781       if(fObj->InheritsFrom("TNamed")){
782         ((TNamed*)fObj)->SetName(fESDListName[i]);
783       }
784       else if(fObj->InheritsFrom("TClonesArray")){
785         ((TClonesArray*)fObj)->SetName(fESDListName[i]);
786       }
787     }
788   }
789   else{
790     printf("%s:%d SetStdNames() Wrong number of Std Entries \n",(char*)__FILE__,__LINE__);
791   }
792
793
794 void AliESDEvent::CreateStdContent() 
795 {
796   // create the standard AOD content and set pointers
797
798   // create standard objects and add them to the TList of objects
799   AddObject(new AliESDRun());
800   AddObject(new AliESDHeader());
801   AddObject(new AliESDZDC());
802   AddObject(new AliESDFMD());
803   AddObject(new AliESDVZERO());
804   AddObject(new AliESDTZERO());
805   AddObject(new AliESDVertex());
806   AddObject(new AliESDVertex());
807   AddObject(new AliMultiplicity());
808   AddObject(new AliESDCaloTrigger());
809   AddObject(new AliESDCaloTrigger());
810   AddObject(new TClonesArray("AliESDtrack",0));
811   AddObject(new TClonesArray("AliESDMuonTrack",0));
812   AddObject(new TClonesArray("AliESDPmdTrack",0));
813   AddObject(new TClonesArray("AliESDTrdTrack",0));
814   AddObject(new TClonesArray("AliESDv0",0));
815   AddObject(new TClonesArray("AliESDcascade",0));
816   AddObject(new TClonesArray("AliESDkink",0));
817   AddObject(new TClonesArray("AliESDCaloCluster",0));
818   AddObject(new TClonesArray("AliRawDataErrorLog",0));
819
820   // check the order of the indices against enum...
821
822   // set names
823   SetStdNames();
824   // read back pointers
825   GetStdContent();
826 }
827
828 TObject* AliESDEvent::FindListObject(const char *name){
829   if(fESDObjects)return fESDObjects->FindObject(name);
830   return 0;
831
832
833 Int_t AliESDEvent::GetPHOSClusters(TRefArray *clusters) const
834 {
835   // fills the provided TRefArray with all found phos clusters
836
837   clusters->Clear();
838
839   AliESDCaloCluster *cl = 0;
840   for (Int_t i = 0; i < GetNumberOfCaloClusters(); i++) {
841
842     if ( cl = GetCaloCluster(i)) {
843       if (cl->IsPHOS()){
844         clusters->Add(cl);
845         printf("IsPHOS %d Size: %d \n",i,clusters->GetEntriesFast());
846       }
847     }
848   }
849   return clusters->GetEntriesFast();
850 }
851
852 Int_t AliESDEvent::GetEMCALClusters(TRefArray *clusters) const
853 {
854   // fills the provided TRefArray with all found phos clusters
855
856   clusters->Clear();
857
858   AliESDCaloCluster *cl = 0;
859   for (Int_t i = 0; i < GetNumberOfCaloClusters(); i++) {
860
861     if ( cl = GetCaloCluster(i)) {
862       if (cl->IsEMCAL()){
863         clusters->Add(cl);
864         printf("IsEMCAL %d Size: %d \n",i,clusters->GetEntriesFast());
865       }
866     }
867   }
868   return clusters->GetEntriesFast();
869 }
870
871
872 void AliESDEvent::ReadFromTree(TTree *tree){
873
874   // load the TTree
875   tree->LoadTree(0);
876
877   // if we find the "ESD" branch on the tree we do have the old structure
878   if(tree->GetBranch("ESD")){
879       char ** address = (char **)(tree->GetBranch("ESD")->GetAddress());
880       if (!address) {
881           printf("%s %d AliESDEvent::ReadFromTree() Reading old Tree \n",(char*)__FILE__,__LINE__);
882           tree->SetBranchAddress("ESD",&fESDOld);
883       } else {
884           printf("%s %d AliESDEvent::ReadFromTree() Reading old Tree \n",(char*)__FILE__,__LINE__);
885           printf("%s %d Branch already connected. Using existing branch address. \n",(char*)__FILE__,__LINE__);
886           fESDOld = (AliESD*) (*address);
887       }
888       
889       
890       CreateStdContent(); // create for copy
891       // when reading back we are not owner of the list 
892       // must not delete it
893       fESDObjects->SetOwner(kFALSE);
894       return;
895   }
896
897   fESDOld = 0;
898
899
900   // Try to find AliESDEvent
901   AliESDEvent *esdEvent = 0;
902   esdEvent = (AliESDEvent*)tree->GetTree()->GetUserInfo()->FindObject("AliESDEvent");
903   //esdEvent = (AliESDEvent*)tree->GetUserInfo()->FindObject("AliESDEvent");
904
905   if(esdEvent){   
906       // Check if already connected to tree
907     TList* connectedList = (TList*) (tree->GetUserInfo()->FindObject("ESDObjectsConnectedToTree"));
908     if (connectedList) {
909       // If connected use the connected list if objects
910       fESDObjects->Delete();
911       fESDObjects = connectedList;
912       GetStdContent(); 
913       fConnected = true;
914       return;
915     }
916     // Connect to tree
917     if(fESDObjects->GetEntries()!=0){
918       // this should not happen here put a warning?
919     }
920     // prevent a memory leak when reading back the TList
921     delete fESDObjects;
922     fESDObjects = 0;
923     // create a new TList from the UserInfo TList... 
924     // copy constructor does not work...
925     fESDObjects = (TList*)(esdEvent->GetList()->Clone());
926     fESDObjects->SetOwner(kFALSE);
927     if(fESDObjects->GetEntries()<kESDListN){
928       printf("%s %d AliESDEvent::ReadFromTree() TList contains less than the standard contents %d < %d \n",
929              (char*)__FILE__,__LINE__,fESDObjects->GetEntries(),kESDListN);
930     }
931     // set the branch addresses
932     TIter next(fESDObjects);
933     TNamed *el;
934     while((el=(TNamed*)next())){
935       TString bname(el->GetName());
936       
937       if(bname.CompareTo("AliESDfriend")==0)
938         {
939           // AliESDfriend does not have a name ...
940           tree->SetBranchAddress("ESDfriend.",fESDObjects->GetObjectRef(el));
941         }
942       else{
943         tree->SetBranchAddress(bname.Data(),fESDObjects->GetObjectRef(el));
944       }
945     }
946     GetStdContent();
947     // when reading back we are not owner of the list 
948     // must not delete it
949     fESDObjects->SetOwner(kFALSE);
950     fESDObjects->SetName("ESDObjectsConnectedToTree");
951     // we are not owner of the list objects 
952     // must not delete it
953     tree->GetUserInfo()->Add(fESDObjects);
954     fConnected = true;
955   }// no esdEvent
956   else {
957     // we can't get the list from the user data, create standard content
958     // and set it by hand (no ESDfriend at the moment
959     CreateStdContent();
960     TIter next(fESDObjects);
961     TNamed *el;
962     while((el=(TNamed*)next())){
963       TString bname(el->GetName());    
964       tree->SetBranchAddress(bname.Data(),fESDObjects->GetObjectRef(el));
965     }
966     GetStdContent();
967     // when reading back we are not owner of the list 
968     // must not delete it
969     fESDObjects->SetOwner(kFALSE);
970   }
971
972
973
974 }
975
976
977 void AliESDEvent::CopyFromOldESD()
978 {
979   // Method which copies over everthing from the old esd structure to the 
980   // new  
981
982   if(fESDOld){
983     ResetStdContent();
984      // Run
985     SetRunNumber(fESDOld->GetRunNumber());
986     SetPeriodNumber(fESDOld->GetPeriodNumber());
987     SetMagneticField(fESDOld->GetMagneticField());
988   
989     // leave out diamond ...
990     // SetDiamond(const AliESDVertex *vertex) { fESDRun->SetDiamond(vertex);}
991
992     // header
993     SetTriggerMask(fESDOld->GetTriggerMask());
994     SetOrbitNumber(fESDOld->GetOrbitNumber());
995     SetTimeStamp(fESDOld->GetTimeStamp());
996     SetEventType(fESDOld->GetEventType());
997     SetEventNumberInFile(fESDOld->GetEventNumberInFile());
998     SetBunchCrossNumber(fESDOld->GetBunchCrossNumber());
999     SetTriggerCluster(fESDOld->GetTriggerCluster());
1000
1001     // ZDC
1002
1003     SetZDC(fESDOld->GetZDCN1Energy(),
1004            fESDOld->GetZDCP1Energy(),
1005            fESDOld->GetZDCEMEnergy(),
1006            fESDOld->GetZDCN2Energy(),
1007            fESDOld->GetZDCP2Energy(),
1008            fESDOld->GetZDCParticipants());
1009
1010     // FMD
1011     
1012     if(fESDOld->GetFMDData())SetFMDData(fESDOld->GetFMDData());
1013
1014     // T0
1015
1016     SetT0zVertex(fESDOld->GetT0zVertex());
1017     SetT0(fESDOld->GetT0());
1018     //  leave amps out
1019
1020     // VZERO
1021     if (fESDOld->GetVZEROData()) SetVZEROData(fESDOld->GetVZEROData());
1022
1023     if(fESDOld->GetVertex())SetVertex(fESDOld->GetVertex());
1024
1025     if(fESDOld->GetPrimaryVertex())SetPrimaryVertex(fESDOld->GetPrimaryVertex());
1026
1027     if(fESDOld->GetMultiplicity())SetMultiplicity(fESDOld->GetMultiplicity());
1028     
1029     for(int i = 0;i<fESDOld->GetNumberOfTracks();i++){
1030       AddTrack(fESDOld->GetTrack(i));
1031     }
1032
1033     for(int i = 0;i<fESDOld->GetNumberOfMuonTracks();i++){
1034       AddMuonTrack(fESDOld->GetMuonTrack(i));
1035     }
1036
1037     for(int i = 0;i<fESDOld->GetNumberOfPmdTracks();i++){
1038       AddPmdTrack(fESDOld->GetPmdTrack(i));
1039     }
1040
1041     for(int i = 0;i<fESDOld->GetNumberOfTrdTracks();i++){
1042       AddTrdTrack(fESDOld->GetTrdTrack(i));
1043     }
1044
1045     for(int i = 0;i<fESDOld->GetNumberOfV0s();i++){
1046       AddV0(fESDOld->GetV0(i));
1047     }
1048
1049     for(int i = 0;i<fESDOld->GetNumberOfCascades();i++){
1050       AddCascade(fESDOld->GetCascade(i));
1051     }
1052
1053     for(int i = 0;i<fESDOld->GetNumberOfKinks();i++){
1054       AddKink(fESDOld->GetKink(i));
1055     }
1056
1057
1058     for(int i = 0;i<fESDOld->GetNumberOfCaloClusters();i++){
1059       AddCaloCluster(fESDOld->GetCaloCluster(i));
1060     }
1061   }// if fesdold
1062 }
1063
1064
1065