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