New detector AD
[u/mrichter/AliRoot.git] / STEER / ESD / AliESD.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: AliESD.cxx 54579 2012-02-14 12:22:34Z shahoian $ */
17
18 //-----------------------------------------------------------------
19 //           Implementation of the ESD class
20 //   This is the class to deal with during the phisical analysis of data
21 //   This class is generated directly by the reconstruction methods
22 //      Origin: Iouri Belikov, CERN, Jouri.Belikov@cern.ch
23 //-----------------------------------------------------------------
24
25 #include "AliESD.h"
26 #include "AliESDfriend.h"
27
28 ClassImp(AliESD)
29
30 //______________________________________________________________________________
31 AliESD::AliESD():
32   fEventNumberInFile(0),
33   fBunchCrossNumber(0),
34   fOrbitNumber(0),
35   fPeriodNumber(0),
36   fRunNumber(0),
37   fTimeStamp(0),
38   fEventType(0),
39   fTriggerMask(0),
40   fTriggerCluster(0),
41   fRecoVersion(0),
42   fMagneticField(0),
43   fZDCN1Energy(0),
44   fZDCP1Energy(0),
45   fZDCN2Energy(0),
46   fZDCP2Energy(0),
47   fZDCEMEnergy(0),
48   fZDCParticipants(0),
49   fT0zVertex(0),
50   fSPDVertex(),
51   fPrimaryVertex(),
52   fSPDMult(),
53   fT0clock(0),
54   fT0timeStart(0),
55   fT0trig(0),
56   fTracks("AliESDtrack",15000),
57   fHLTConfMapTracks("AliESDHLTtrack",25000),
58   fHLTHoughTracks("AliESDHLTtrack",15000),
59   fMuonTracks("AliESDMuonTrack",30),
60   fPmdTracks("AliESDPmdTrack",3000),
61   fTrdTracks("AliESDTrdTrack",300),
62   fV0s("AliESDv0",200),  
63   fCascades("AliESDcascade",20),
64   fKinks("AliESDkink",4000),
65   fCaloClusters("AliESDCaloCluster",10000),
66   fEMCALClusters(0), 
67   fFirstEMCALCluster(-1),
68   fEMCALTriggerPosition(0x0),
69   fEMCALTriggerAmplitudes(0x0),
70   fPHOSClusters(0), 
71   fFirstPHOSCluster(-1),
72   fPHOSTriggerPosition(0x0),
73   fPHOSTriggerAmplitudes(0x0),
74   fESDFMD(0x0),
75   fESDVZERO(0x0),
76   fESDACORDE(0x0),
77   fESDAD(0x0),
78   fErrorLogs("AliRawDataErrorLog",5)
79   #ifdef MFT_UPGRADE
80  // ,fESDMFT(0x0)
81   #endif
82 {
83   // 
84   // Standar constructor
85   //
86
87    for (Int_t i=0; i<3; i++) fT0TOF[i] = 0;
88  for (Int_t i=0; i<24; i++) {
89     fT0time[i] = 0;
90     fT0amplitude[i] = 0;
91   }
92   for (Int_t i=0; i<2; i++) fDiamondXY[i]=0.;
93   for (Int_t i=0; i<3; i++) fDiamondCovXY[i]=0.;
94 }
95
96 //______________________________________________________________________________
97 AliESD::AliESD(const AliESD& esd):
98   TObject(esd),
99   fEventNumberInFile(esd.fEventNumberInFile),
100   fBunchCrossNumber(esd.fBunchCrossNumber),
101   fOrbitNumber(esd.fOrbitNumber),
102   fPeriodNumber(esd.fPeriodNumber),
103   fRunNumber(esd.fRunNumber),
104   fTimeStamp(esd.fTimeStamp),
105   fEventType(esd.fEventType),
106   fTriggerMask(esd.fTriggerMask),
107   fTriggerCluster(esd.fTriggerCluster),
108   fRecoVersion(esd.fRecoVersion),
109   fMagneticField(esd.fMagneticField),
110   fZDCN1Energy(esd.fZDCN1Energy),
111   fZDCP1Energy(esd.fZDCP1Energy),
112   fZDCN2Energy(esd.fZDCN2Energy),
113   fZDCP2Energy(esd.fZDCP2Energy),
114   fZDCEMEnergy(esd.fZDCEMEnergy),
115   fZDCParticipants(esd.fZDCParticipants),
116   fT0zVertex(esd.fT0zVertex),
117   fSPDVertex(esd.fSPDVertex),
118   fPrimaryVertex(esd.fPrimaryVertex),
119   fSPDMult(esd.fSPDMult),
120   fT0clock(esd.fT0clock),
121   fT0timeStart(esd.fT0timeStart),
122   fT0trig(esd.fT0trig),
123   fTracks(*((TClonesArray*)esd.fTracks.Clone())),
124   fHLTConfMapTracks(*((TClonesArray*)esd.fHLTConfMapTracks.Clone())),
125   fHLTHoughTracks(*((TClonesArray*)esd.fHLTHoughTracks.Clone())),
126   fMuonTracks(*((TClonesArray*)esd.fMuonTracks.Clone())),
127   fPmdTracks(*((TClonesArray*)esd.fPmdTracks.Clone())),
128   fTrdTracks(*((TClonesArray*)esd.fTrdTracks.Clone())),
129   fV0s(*((TClonesArray*)esd.fV0s.Clone())),  
130   fCascades(*((TClonesArray*)esd.fCascades.Clone())),
131   fKinks(*((TClonesArray*)esd.fKinks.Clone())),
132   fCaloClusters(*((TClonesArray*)esd.fCaloClusters.Clone())),
133   fEMCALClusters(esd.fEMCALClusters), 
134   fFirstEMCALCluster(esd.fFirstEMCALCluster),
135   fEMCALTriggerPosition(esd. fEMCALTriggerPosition),
136   fEMCALTriggerAmplitudes(esd.fEMCALTriggerAmplitudes),
137   fPHOSClusters(esd.fPHOSClusters), 
138   fFirstPHOSCluster(esd.fFirstPHOSCluster),
139   fPHOSTriggerPosition(esd.fPHOSTriggerPosition),
140   fPHOSTriggerAmplitudes(esd.fPHOSTriggerAmplitudes),
141   fESDFMD(esd.fESDFMD),
142   fESDVZERO(esd.fESDVZERO),
143   fESDACORDE(esd.fESDACORDE),
144   fESDAD(esd.fESDAD),
145   fErrorLogs(*((TClonesArray*)esd.fErrorLogs.Clone()))
146   #ifdef MFT_UPGRADE
147   //, fESDMFT(esd.fESDMFT)
148   #endif
149 {
150   // 
151   // copy constructor
152   //
153   for (Int_t i=0; i<3; i++)fT0TOF[i] = esd.fT0TOF[i];
154   for (Int_t i=0; i<24; i++) {
155     fT0time[i] = esd.fT0time[i];
156     fT0amplitude[i] = esd.fT0amplitude[i];
157   }
158   for (Int_t i=0; i<2; i++) fDiamondXY[i]=esd.fDiamondXY[i];
159   for (Int_t i=0; i<3; i++) fDiamondCovXY[i]=esd.fDiamondCovXY[i];
160 }
161
162 //______________________________________________________________________________
163 AliESD::~AliESD()
164 {
165   //
166   // Standard destructor
167   //
168   fTracks.Delete();
169   fHLTConfMapTracks.Delete();
170   fHLTHoughTracks.Delete();
171   fMuonTracks.Delete();
172   fPmdTracks.Delete();
173   fTrdTracks.Delete();
174   fV0s.Delete();
175   fCascades.Delete();
176   fKinks.Delete();
177   fCaloClusters.Delete();
178   delete fESDFMD;
179   delete fESDVZERO;
180   delete fEMCALTriggerPosition;
181   delete fEMCALTriggerAmplitudes;
182   delete fPHOSTriggerPosition;
183   delete fPHOSTriggerAmplitudes;
184   delete fESDACORDE;
185   delete fESDAD;
186   #ifdef MFT_UPGRADE
187 //  delete fESDMFT;
188   #endif
189   fErrorLogs.Delete();
190
191 }
192
193 //______________________________________________________________________________
194 void AliESD::Reset()
195 {
196   // 
197   // Reset the contents and delete the entries in TClonesArrays
198   //
199
200   fEventNumberInFile=0;
201   fBunchCrossNumber=0;
202   fOrbitNumber=0;
203   fPeriodNumber=0;
204   fRunNumber=0;
205   fTimeStamp = 0;
206   fEventType = 0;
207   fTriggerMask=0;
208   fTriggerCluster=0;
209   fRecoVersion=0;
210   fMagneticField=0;
211   fZDCN1Energy=0;
212   fZDCP1Energy=0;
213   fZDCN2Energy=0;
214   fZDCP2Energy=0;
215   fZDCEMEnergy=0;
216   fZDCParticipants=0;
217   fT0zVertex=0;
218   
219   for (Int_t i=0; i<2; i++) fDiamondXY[i]=0.;
220   for (Int_t i=0; i<3; i++) fDiamondCovXY[i]=0.;
221
222   for (Int_t i=0; i<24; i++) {
223     fT0time[i] = 0;
224     fT0amplitude[i] = 0;
225   }
226   fT0timeStart = 0;
227   fT0clock = 0;
228   for (Int_t i=0; i<3; i++) fT0TOF[i] = 0;
229 //
230   fSPDMult.~AliMultiplicity();
231   new (&fSPDMult) AliMultiplicity();
232   fSPDVertex.~AliESDVertex();
233   new (&fSPDVertex) AliESDVertex();
234   fPrimaryVertex.~AliESDVertex();
235   new (&fPrimaryVertex) AliESDVertex();
236 //
237   fTracks.Delete();
238   fHLTConfMapTracks.Delete();
239   fHLTHoughTracks.Delete();
240   fMuonTracks.Delete();
241   fPmdTracks.Delete();
242   fTrdTracks.Delete();
243   fV0s.Delete();
244   fCascades.Delete();
245   fKinks.Delete();
246   fCaloClusters.Delete();
247 //
248   fEMCALClusters=0; 
249   fFirstEMCALCluster=-1; 
250   fPHOSClusters=0; 
251   fFirstPHOSCluster=-1; 
252 //
253   if (fEMCALTriggerPosition)   fEMCALTriggerPosition  ->Reset();
254   if (fEMCALTriggerAmplitudes) fEMCALTriggerAmplitudes->Reset();
255   if (fPHOSTriggerPosition)    fPHOSTriggerPosition   ->Reset();
256   if (fPHOSTriggerAmplitudes)  fPHOSTriggerAmplitudes ->Reset();
257 //
258   if (fESDFMD) fESDFMD->Clear();
259 //
260   if (fESDVZERO){
261       fESDVZERO->~AliESDVZERO();
262       new (fESDVZERO) AliESDVZERO();
263   } 
264 //
265   if (fESDACORDE){
266       fESDACORDE->~AliESDACORDE();
267       new (fESDACORDE) AliESDACORDE();  
268   }     
269
270  if (fESDAD){
271       fESDAD->~AliESDAD();
272       new (fESDAD) AliESDAD();  
273   }     
274
275 //
276   #ifdef MFT_UPGRADE
277  // if (fESDMFT){
278 //        fESDMFT->~AliESDMFT();
279 //        new (fESDMFT) AliESDMFT();    
280 //  }
281   #endif
282 //
283   fErrorLogs.Delete();
284 }
285
286
287 Bool_t  AliESD::RemoveKink(Int_t rm) {
288   // ---------------------------------------------------------
289   // Remove a kink candidate and references to it from ESD,
290   // if this candidate does not come from a reconstructed decay
291   // Not yet implemented...
292   // ---------------------------------------------------------
293   Int_t last=GetNumberOfKinks()-1;
294   if ((rm<0)||(rm>last)) return kFALSE;
295
296   return kTRUE;
297 }
298
299 Bool_t  AliESD::RemoveV0(Int_t rm) {
300   // ---------------------------------------------------------
301   // Remove a V0 candidate and references to it from ESD,
302   // if this candidate does not come from a reconstructed decay
303   // ---------------------------------------------------------
304   Int_t last=GetNumberOfV0s()-1;
305   if ((rm<0)||(rm>last)) return kFALSE;
306
307   AliESDv0 *v0=GetV0(rm);
308   Int_t idxP=v0->GetPindex(), idxN=v0->GetNindex();
309
310   v0=GetV0(last);
311   Int_t lastIdxP=v0->GetPindex(), lastIdxN=v0->GetNindex();
312
313   Int_t used=0;
314
315   // Check if this V0 comes from a reconstructed decay
316   Int_t ncs=GetNumberOfCascades();
317   for (Int_t n=0; n<ncs; n++) {
318     AliESDcascade *cs=GetCascade(n);
319
320     Int_t csIdxP=cs->GetPindex();
321     Int_t csIdxN=cs->GetNindex();
322
323     if (idxP==csIdxP)
324        if (idxN==csIdxN) return kFALSE;
325
326     if (csIdxP==lastIdxP)
327        if (csIdxN==lastIdxN) used++;
328   }
329
330   //Replace the removed V0 with the last V0 
331   TClonesArray &a=fV0s;
332   delete a.RemoveAt(rm);
333
334   if (rm==last) return kTRUE;
335
336   //v0 is pointing to the last V0 candidate... 
337   new (a[rm]) AliESDv0(*v0);
338   delete a.RemoveAt(last);
339
340   if (!used) return kTRUE;
341   
342
343   // Remap the indices of the daughters of reconstructed decays
344   for (Int_t n=0; n<ncs; n++) {
345     AliESDcascade *cs=GetCascade(n);
346
347
348     Int_t csIdxP=cs->GetPindex();
349     Int_t csIdxN=cs->GetNindex();
350
351     if (csIdxP==lastIdxP)
352       if (csIdxN==lastIdxN) {
353          cs->AliESDv0::SetIndex(1,idxP);
354          cs->AliESDv0::SetIndex(0,idxN);
355          used--;
356          if (!used) return kTRUE;
357       }
358   }
359
360   return kTRUE;
361 }
362
363 Bool_t  AliESD::RemoveTrack(Int_t rm) {
364   // ---------------------------------------------------------
365   // Remove a track and references to it from ESD,
366   // if this track does not come from a reconstructed decay
367   // ---------------------------------------------------------
368   Int_t last=GetNumberOfTracks()-1;
369   if ((rm<0)||(rm>last)) return kFALSE;
370
371   Int_t used=0;
372
373   // Check if this track comes from the reconstructed primary vertex
374   if (fPrimaryVertex.GetStatus()) {
375      UShort_t *primIdx=fPrimaryVertex.GetIndices();
376      Int_t n=fPrimaryVertex.GetNIndices();
377      while (n--) {
378        Int_t idx=Int_t(primIdx[n]);
379        if (rm==idx) return kFALSE;
380        if (idx==last) used++; 
381      }
382   }
383   
384   // Check if this track comes from a reconstructed decay
385   Int_t nv0=GetNumberOfV0s();
386   for (Int_t n=0; n<nv0; n++) {
387     AliESDv0 *v0=GetV0(n);
388
389     Int_t idx=v0->GetNindex();
390     if (rm==idx) return kFALSE;
391     if (idx==last) used++;
392
393     idx=v0->GetPindex();
394     if (rm==idx) return kFALSE;
395     if (idx==last) used++;
396   }
397
398   Int_t ncs=GetNumberOfCascades();
399   for (Int_t n=0; n<ncs; n++) {
400     AliESDcascade *cs=GetCascade(n);
401
402     Int_t idx=cs->GetIndex();
403     if (rm==idx) return kFALSE;
404     if (idx==last) used++;
405   }
406
407   Int_t nkn=GetNumberOfKinks();
408   for (Int_t n=0; n<nkn; n++) {
409     AliESDkink *kn=GetKink(n);
410
411     Int_t idx=kn->GetIndex(0);
412     if (rm==idx) return kFALSE;
413     if (idx==last) used++;
414
415     idx=kn->GetIndex(1);
416     if (rm==idx) return kFALSE;
417     if (idx==last) used++;
418   }
419
420
421   //Replace the removed track with the last track 
422   TClonesArray &a=fTracks;
423   delete a.RemoveAt(rm);
424
425   if (rm==last) return kTRUE;
426
427   AliESDtrack *t=GetTrack(last);
428   if (!t) {AliFatal(Form("NULL pointer for ESD track %d",last));}
429   t->SetID(rm);
430   new (a[rm]) AliESDtrack(*t);
431   delete a.RemoveAt(last);
432
433
434   if (!used) return kTRUE;
435   
436
437   // Remap the indices of the tracks used for the primary vertex reconstruction
438   if (fPrimaryVertex.GetStatus()) {
439      UShort_t *primIdx=fPrimaryVertex.GetIndices();
440      Int_t n=fPrimaryVertex.GetNIndices();
441      while (n--) {
442        Int_t idx=Int_t(primIdx[n]);
443        if (idx==last) {
444           primIdx[n]=Short_t(rm); 
445           used--;
446           if (!used) return kTRUE;
447        }
448      }
449   }
450   
451   // Remap the indices of the daughters of reconstructed decays
452   for (Int_t n=0; n<nv0; n++) {
453     AliESDv0 *v0=GetV0(n);
454     if (v0->GetIndex(0)==last) {
455        v0->SetIndex(0,rm);
456        used--;
457        if (!used) return kTRUE;
458     }
459     if (v0->GetIndex(1)==last) {
460        v0->SetIndex(1,rm);
461        used--;
462        if (!used) return kTRUE;
463     }
464   }
465
466   for (Int_t n=0; n<ncs; n++) {
467     AliESDcascade *cs=GetCascade(n);
468     if (cs->GetIndex()==last) {
469        cs->SetIndex(rm);
470        used--;
471        if (!used) return kTRUE;
472     }
473   }
474
475   for (Int_t n=0; n<nkn; n++) {
476     AliESDkink *kn=GetKink(n);
477     if (kn->GetIndex(0)==last) {
478        kn->SetIndex(rm,0);
479        used--;
480        if (!used) return kTRUE;
481     }
482     if (kn->GetIndex(1)==last) {
483        kn->SetIndex(rm,1);
484        used--;
485        if (!used) return kTRUE;
486     }
487   }
488
489   return kTRUE;
490 }
491
492
493 Bool_t AliESD::Clean(Float_t *cleanPars) {
494   //
495   // Remove the data which are not needed for the physics analysis.
496   //
497   // 1) Cleaning the V0 candidates
498   //    ---------------------------
499   //    If the cosine of the V0 pointing angle "csp" and 
500   //    the DCA between the daughter tracks "dca" does not satisfy 
501   //    the conditions 
502   //
503   //     csp > cleanPars[1] + dca/cleanPars[0]*(1.- cleanPars[1])
504   //
505   //    an attempt to remove this V0 candidate from ESD is made.
506   //
507   //    The V0 candidate gets removed if it does not belong to any 
508   //    recosntructed cascade decay
509   //
510   //    12.11.2007, optimal values: cleanPars[0]=0.5, cleanPars[1]=0.999
511   //
512   // 2) Cleaning the tracks
513   //    ----------------------
514   //    If track's transverse parameter is larger than cleanPars[2]
515   //                       OR
516   //    track's longitudinal parameter is larger than cleanPars[3]
517   //    an attempt to remove this track from ESD is made.
518   //
519   //    The track gets removed if it does not come 
520   //    from a reconstructed decay
521   //
522   Bool_t rc=kFALSE;
523
524   Float_t dcaMax=cleanPars[0];
525   Float_t cspMin=cleanPars[1];
526
527   Int_t nV0s=GetNumberOfV0s();
528   for (Int_t i=nV0s-1; i>=0; i--) {
529     AliESDv0 *v0=GetV0(i);
530
531     Float_t dca=v0->GetDcaV0Daughters();
532     Float_t csp=v0->GetV0CosineOfPointingAngle();
533     Float_t cspcut=cspMin + dca/dcaMax*(1.-cspMin);
534     if (csp > cspcut) continue;
535
536     if (RemoveV0(i)) rc=kTRUE;
537   }
538
539
540   Float_t dmax=cleanPars[2], zmax=cleanPars[3];
541
542   const AliESDVertex *vertex=GetVertex();
543   Bool_t vtxOK=vertex->GetStatus();
544   
545   Int_t nTracks=GetNumberOfTracks();
546   for (Int_t i=nTracks-1; i>=0; i--) {
547     AliESDtrack *track=GetTrack(i);
548     if (!track) {AliFatal(Form("NULL pointer for ESD track %d",i));}
549     Float_t xy,z; track->GetImpactParameters(xy,z);
550     if ((TMath::Abs(xy) > dmax) || (vtxOK && (TMath::Abs(z) > zmax))) {
551       if (RemoveTrack(i)) rc=kTRUE;
552     }
553   }
554
555   return rc;
556 }
557
558 Int_t AliESD::AddV0(const AliESDv0 *v) {
559   //
560   // Add V0
561   //
562     Int_t idx=fV0s.GetEntriesFast();
563     new(fV0s[idx]) AliESDv0(*v);
564     return idx;
565 }  
566
567 //______________________________________________________________________________
568 void AliESD::Print(Option_t *) const 
569 {
570   //
571   // Print header information of the event
572   //
573   printf("ESD run information\n");
574   printf("Event # in file %d Bunch crossing # %d Orbit # %d Period # %d Run # %d Trigger %lld Magnetic field %f \n",
575          GetEventNumberInFile(),
576          GetBunchCrossNumber(),
577          GetOrbitNumber(),
578          GetPeriodNumber(),
579          GetRunNumber(),
580          GetTriggerMask(),
581          GetMagneticField() );
582     printf("Vertex: (%.4f +- %.4f, %.4f +- %.4f, %.4f +- %.4f) cm\n",
583            fPrimaryVertex.GetXv(), fPrimaryVertex.GetXRes(),
584            fPrimaryVertex.GetYv(), fPrimaryVertex.GetYRes(),
585            fPrimaryVertex.GetZv(), fPrimaryVertex.GetZRes());
586     printf("Mean vertex in RUN: X=%.4f Y=%.4f cm\n",
587            GetDiamondX(),GetDiamondY());
588     printf("SPD Multiplicity. Number of tracklets %d \n",
589            fSPDMult.GetNumberOfTracklets());
590   printf("Event from reconstruction version %d \n",fRecoVersion);
591   printf("Number of tracks: \n");
592   printf("                 charged   %d\n", GetNumberOfTracks());
593   printf("                 hlt CF    %d\n", GetNumberOfHLTConfMapTracks());
594   printf("                 hlt HT    %d\n", GetNumberOfHLTHoughTracks());
595   printf("                 muon      %d\n", GetNumberOfMuonTracks());
596   printf("                 pmd       %d\n", GetNumberOfPmdTracks());
597   printf("                 trd       %d\n", GetNumberOfTrdTracks());
598   printf("                 v0        %d\n", GetNumberOfV0s());
599   printf("                 cascades  %d\n", GetNumberOfCascades());
600   printf("                 kinks     %d\n", GetNumberOfKinks());
601   printf("                 CaloClusters %d\n", GetNumberOfCaloClusters());
602   printf("                 phos      %d\n", GetNumberOfPHOSClusters());
603   printf("                 emcal     %d\n", GetNumberOfEMCALClusters());
604   printf("                 FMD       %s\n", (fESDFMD ? "yes" : "no"));
605   printf("                 VZERO     %s\n", (fESDVZERO ? "yes" : "no"));
606   #ifdef MFT_UPGRADE
607  // printf("                 MFT       %s\n", (fESDMFT ? "yes" : "no"));
608   #endif
609 }
610
611 void AliESD::SetESDfriend(const AliESDfriend *ev) {
612   //
613   // Attaches the complementary info to the ESD
614   //
615   if (!ev) return;
616
617   Int_t ntrk=ev->GetNumberOfTracks();
618
619   for (Int_t i=0; i<ntrk; i++) {
620     const AliESDfriendTrack *f=ev->GetTrack(i);
621     if (!f) {AliFatal(Form("NULL pointer for ESD track %d",i));}
622     GetTrack(i)->SetFriendTrack(f);
623   }
624 }
625
626 void AliESD::GetESDfriend(AliESDfriend *ev) const {
627   //
628   // Extracts the complementary info from the ESD
629   //
630   if (!ev) return;
631
632   Int_t ntrk=GetNumberOfTracks();
633
634   for (Int_t i=0; i<ntrk; i++) {
635     AliESDtrack *t=GetTrack(i);
636     if (!t) {AliFatal(Form("NULL pointer for ESD track %d",i));}
637     const AliESDfriendTrack *f=t->GetFriendTrack();
638     ev->AddTrack(f);
639
640     t->ReleaseESDfriendTrack();// Not to have two copies of "friendTrack"
641
642   }
643 }
644
645 void AliESD::SetDiamond(const AliESDVertex *vertex)
646 {
647   //
648   // Set the interaction diamond
649   //  
650     fDiamondXY[0]=vertex->GetXv();
651     fDiamondXY[1]=vertex->GetYv();
652     Double_t cov[6];
653     vertex->GetCovMatrix(cov);
654     fDiamondCovXY[0]=cov[0];
655     fDiamondCovXY[1]=cov[1];
656     fDiamondCovXY[2]=cov[2];
657   }