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