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 "TList.h"
  26 #include <TNamed.h>
  27
  28 #include "AliESD.h"
  29 #include "AliESDfriend.h"
  30 #include "AliESDVZERO.h"
  31 #include "AliESDHLTtrack.h"
  32 #include "AliESDFMD.h"
  33
  34
  35 ClassImp(AliESD)
  36
  37 //______________________________________________________________________________
  38 AliESD::AliESD():
  39   fESDObjects(new TList()),
  40   fESDRun(0),
  41   fHeader(0),
  42   fESDZDC(0),
  43   fESDFMD(0),
  44   fESDVZERO(0),
  45   fESDTZERO(0),
  46   fSPDVertex(0),
  47   fPrimaryVertex(0),
  48   fSPDMult(0),
  49   fPHOSTrigger(0),
  50   fEMCALTrigger(0),
  51   fTracks(0),
  52   fMuonTracks(0),
  53   fPmdTracks(0),
  54   fTrdTracks(0),
  55   fV0s(0),
  56   fCascades(0),
  57   fKinks(0),
  58   fCaloClusters(0),
  59   fErrorLogs(0),
  60   fEMCALClusters(0),
  61   fFirstEMCALCluster(-1),
  62   fPHOSClusters(0),
  63   fFirstPHOSCluster(-1)
  64 {
  65 }
  66 //______________________________________________________________________________
  67 AliESD::AliESD(const AliESD& esd):
  68   TObject(esd),
  69   fESDObjects(new TList()),
  70   fESDRun(new AliESDRun(*esd.fESDRun)),
  71   fHeader(new AliESDHeader(*esd.fHeader)),
  72   fESDZDC(new AliESDZDC(*esd.fESDZDC)),
  73   fESDFMD(new AliESDFMD(*esd.fESDFMD)),
  74   fESDVZERO(new AliESDVZERO(*esd.fESDVZERO)),
  75   fESDTZERO(new AliESDTZERO(*esd.fESDTZERO)),
  76   fSPDVertex(new AliESDVertex(*esd.fSPDVertex)),
  77   fPrimaryVertex(new AliESDVertex(*esd.fPrimaryVertex)),
  78   fSPDMult(new AliMultiplicity(*esd.fSPDMult)),
  79   fPHOSTrigger(new AliESDCaloTrigger(*esd.fPHOSTrigger)),
  80   fEMCALTrigger(new AliESDCaloTrigger(*esd.fEMCALTrigger)),
  81   fTracks(new TClonesArray(*esd.fTracks)),
  82   fMuonTracks(new TClonesArray(*esd.fMuonTracks)),
  83   fPmdTracks(new TClonesArray(*esd.fPmdTracks)),
  84   fTrdTracks(new TClonesArray(*esd.fTrdTracks)),
  85   fV0s(new TClonesArray(*esd.fV0s)),
  86   fCascades(new TClonesArray(*esd.fCascades)),
  87   fKinks(new TClonesArray(*esd.fKinks)),
  88   fCaloClusters(new TClonesArray(*esd.fCaloClusters)),
  89   fErrorLogs(new TClonesArray(*esd.fErrorLogs)),
  90   fEMCALClusters(esd.fEMCALClusters),
  91   fFirstEMCALCluster(esd.fFirstEMCALCluster),
  92   fPHOSClusters(esd.fPHOSClusters),
  93   fFirstPHOSCluster(esd.fFirstPHOSCluster)
  94
  95 {
  96   // CKB init in the constructor list and only add here ...
  97   AddObject(fESDRun);
  98   AddObject(fHeader);
  99   AddObject(fESDZDC);
 100   AddObject(fESDFMD);
 101   AddObject(fESDVZERO);
 102   AddObject(fESDTZERO);
 103   AddObject(fSPDVertex);
 104   AddObject(fPrimaryVertex);
 105   AddObject(fSPDMult);
 106   AddObject(fPHOSTrigger);
 107   AddObject(fEMCALTrigger);
 108   AddObject(fTracks);
 109   AddObject(fMuonTracks);
 110   AddObject(fPmdTracks);
 111   AddObject(fTrdTracks);
 112   AddObject(fV0s);
 113   AddObject(fCascades);
 114   AddObject(fKinks);
 115   AddObject(fCaloClusters);
 116   AddObject(fErrorLogs);
 117
 118   GetStdContent();
 119
 120 }
 121
 122 //______________________________________________________________________________
 123 AliESD & AliESD::operator=(const AliESD& source) {
 124
 125   // Assignment operator
 126
 127   if(&source == this) return *this;
 128   TObject::operator=(source);
 129
 130   fESDRun = new AliESDRun(*source.fESDRun);
 131   fHeader = new AliESDHeader(*source.fHeader);
 132   fESDZDC = new AliESDZDC(*source.fESDZDC);
 133   fESDFMD = new AliESDFMD(*source.fESDFMD);
 134   fESDVZERO = new AliESDVZERO(*source.fESDVZERO);
 135   fESDTZERO = new AliESDTZERO(*source.fESDTZERO);
 136   fSPDVertex = new AliESDVertex(*source.fSPDVertex);
 137   fPrimaryVertex = new AliESDVertex(*source.fPrimaryVertex);
 138   fSPDMult = new AliMultiplicity(*source.fSPDMult);
 139   fPHOSTrigger = new AliESDCaloTrigger(*source.fPHOSTrigger);
 140   fEMCALTrigger = new AliESDCaloTrigger(*source.fEMCALTrigger);
 141   fTracks = new TClonesArray(*source.fTracks);
 142   fMuonTracks = new TClonesArray(*source.fMuonTracks);
 143   fPmdTracks = new TClonesArray(*source.fPmdTracks);
 144   fTrdTracks = new TClonesArray(*source.fTrdTracks);
 145   fV0s = new TClonesArray(*source.fV0s);
 146   fCascades = new TClonesArray(*source.fCascades);
 147   fKinks = new TClonesArray(*source.fKinks);
 148   fCaloClusters = new TClonesArray(*source.fCaloClusters);
 149   fErrorLogs = new TClonesArray(*source.fErrorLogs);
 150
 151   // CKB this way?? or
 152   // or AddObject(  fESDZDC = new AliESDZDC(*source.fESDZDC));
 153
 154   fESDObjects = new TList();
 155   AddObject(fESDRun);
 156   AddObject(fHeader);
 157   AddObject(fESDZDC);
 158   AddObject(fESDFMD);
 159   AddObject(fESDVZERO);
 160   AddObject(fESDTZERO);
 161   AddObject(fSPDVertex);
 162   AddObject(fPrimaryVertex);
 163   AddObject(fSPDMult);
 164   AddObject(fPHOSTrigger);
 165   AddObject(fEMCALTrigger);
 166   AddObject(fTracks);
 167   AddObject(fMuonTracks);
 168   AddObject(fPmdTracks);
 169   AddObject(fTrdTracks);
 170   AddObject(fV0s);
 171   AddObject(fCascades);
 172   AddObject(fKinks);
 173   AddObject(fCaloClusters);
 174   AddObject(fErrorLogs);
 175
 176
 177   fEMCALClusters = source.fEMCALClusters;
 178   fFirstEMCALCluster = source.fFirstEMCALCluster;
 179   fPHOSClusters = source.fPHOSClusters;
 180   fFirstPHOSCluster = source.fFirstPHOSCluster;
 181
 182
 183
 184   return *this;
 185
 186 }
 187
 188
 189 //______________________________________________________________________________
 190 AliESD::~AliESD()
 191 {
 192   //
 193   // Standard destructor
 194   //
 195
 196   delete fESDObjects;
 197   fESDObjects = 0;
 198
 199   // everthing on the list gets deleted automatically
 200
 201   /*
 202   fHLTConfMapTracks.Delete();
 203   fHLTHoughTracks.Delete();
 204   fMuonTracks.Delete();
 205   fPmdTracks.Delete();
 206   fTrdTracks.Delete();
 207   fV0s.Delete();
 208   fCascades.Delete();
 209   fKinks.Delete();
 210   fCaloClusters.Delete();
 211   */
 212 //   fEMCALTriggerPosition->Delete();
 213 //   fEMCALTriggerAmplitudes->Delete();
 214 //   fPHOSTriggerPosition->Delete();
 215 //   fPHOSTriggerAmplitudes->Delete();
 216 //   delete fEMCALTriggerPosition;
 217 //   delete fEMCALTriggerAmplitudes;
 218 //   delete fPHOSTriggerPosition;
 219 //   delete fPHOSTriggerAmplitudes;
 220
 221 }
 222
 223 //______________________________________________________________________________
 224 void AliESD::Reset()
 225 {
 226   // Reset the standard contents
 227   if(fESDRun) fESDRun->Reset();
 228   if(fHeader) fHeader->Reset();
 229   if(fESDZDC) fESDZDC->Reset();
 230   if(fESDFMD) fESDFMD->Clear(); // why clear.... need consistend names
 231   // if(fESDVZERO) fESDVZERO->; // NOT IMPLEMENTED
 232   //  if(fESDVZERO) new (fESDVZERO) AliESDVZERO();
 233   if(fESDTZERO) fESDTZERO->Reset();
 234   // CKB no clear/reset implemented
 235   if(fSPDVertex){
 236     new (fSPDVertex) AliESDVertex();
 237     fSPDVertex->SetName("SPDVertex");
 238   }
 239   if(fPrimaryVertex){
 240     new (fPrimaryVertex) AliESDVertex();
 241     fPrimaryVertex->SetName("PrimaryVertex");
 242   }
 243   if(fSPDMult)new (fSPDMult) AliMultiplicity();
 244   if(fPHOSTrigger)fPHOSTrigger->Reset();
 245   if(fEMCALTrigger)fEMCALTrigger->Reset();
 246   if(fTracks)fTracks->Clear();
 247   if(fMuonTracks)fMuonTracks->Clear();
 248   if(fPmdTracks)fPmdTracks->Clear();
 249   if(fTrdTracks)fTrdTracks->Clear();
 250   if(fV0s)fV0s->Clear();
 251   if(fCascades)fCascades->Clear();
 252   if(fKinks)fKinks->Clear();
 253   if(fCaloClusters)fCaloClusters->Clear();
 254   if(fErrorLogs) fErrorLogs->Clear();
 255
 256
 257   fEMCALClusters=0;
 258   fFirstEMCALCluster=-1;
 259   fPHOSClusters=0;
 260   fFirstPHOSCluster=-1;
 261 }
 262
 263 Int_t AliESD::AddV0(const AliESDv0 *v) {
 264   //
 265   // Add V0
 266   //
 267   TClonesArray &fv = *fV0s;
 268   Int_t idx=fV0s->GetEntriesFast();
 269   new(fv[idx]) AliESDv0(*v);
 270   return idx;
 271 }
 272
 273 //______________________________________________________________________________
 274 void AliESD::Print(Option_t *) const
 275 {
 276   //
 277   // Print header information of the event
 278   //
 279   printf("ESD run information\n");
 280   printf("Event # in file %d Bunch crossing # %d Orbit # %d Period # %d Run # %d Trigger %lld Magnetic field %f \n",
 281          GetEventNumberInFile(),
 282          GetBunchCrossNumber(),
 283          GetOrbitNumber(),
 284          GetPeriodNumber(),
 285          GetRunNumber(),
 286          GetTriggerMask(),
 287          GetMagneticField() );
 288   printf("Vertex: (%.4f +- %.4f, %.4f +- %.4f, %.4f +- %.4f) cm\n",
 289            fPrimaryVertex->GetXv(), fPrimaryVertex->GetXRes(),
 290            fPrimaryVertex->GetYv(), fPrimaryVertex->GetYRes(),
 291            fPrimaryVertex->GetZv(), fPrimaryVertex->GetZRes());
 292     printf("Mean vertex in RUN: X=%.4f Y=%.4f cm\n",
 293            GetDiamondX(),GetDiamondY());
 294     printf("SPD Multiplicity. Number of tracklets %d \n",
 295            fSPDMult->GetNumberOfTracklets());
 296   printf("Number of tracks: \n");
 297   printf("                 charged   %d\n", GetNumberOfTracks());
 298   printf("                 muon      %d\n", GetNumberOfMuonTracks());
 299   printf("                 pmd       %d\n", GetNumberOfPmdTracks());
 300   printf("                 trd       %d\n", GetNumberOfTrdTracks());
 301   printf("                 v0        %d\n", GetNumberOfV0s());
 302   printf("                 cascades  %d\n", GetNumberOfCascades());
 303   printf("                 kinks     %d\n", GetNumberOfKinks());
 304   printf("                 CaloClusters %d\n", GetNumberOfCaloClusters());
 305   printf("                 phos      %d\n", GetNumberOfPHOSClusters());
 306   printf("                 emcal     %d\n", GetNumberOfEMCALClusters());
 307   printf("                 FMD       %s\n", (fESDFMD ? "yes" : "no"));
 308   printf("                 VZERO     %s\n", (fESDVZERO ? "yes" : "no"));
 309 }
 310
 311 void AliESD::SetESDfriend(const AliESDfriend *ev) {
 312   //
 313   // Attaches the complementary info to the ESD
 314   //
 315   if (!ev) return;
 316
 317   Int_t ntrk=ev->GetNumberOfTracks();
 318
 319   for (Int_t i=0; i<ntrk; i++) {
 320     const AliESDfriendTrack *f=ev->GetTrack(i);
 321     GetTrack(i)->SetFriendTrack(f);
 322   }
 323 }
 324
 325 Int_t  AliESD::AddTrack(const AliESDtrack *t) {
 326     // Add track
 327     TClonesArray &ftr = *fTracks;
 328     AliESDtrack * track = new(ftr[fTracks->GetEntriesFast()])AliESDtrack(*t);
 329     track->SetID(fTracks->GetEntriesFast()-1);
 330     return  track->GetID();
 331 }
 332
 333 Int_t AliESD::AddKink(const AliESDkink *c) {
 334     // Add kink
 335     TClonesArray &fk = *fKinks;
 336     AliESDkink * kink = new(fk[fKinks->GetEntriesFast()]) AliESDkink(*c);
 337     kink->SetID(fKinks->GetEntriesFast()); // CKB different from the other imps..
 338     return fKinks->GetEntriesFast()-1;
 339 }
 340
 341 Int_t AliESD::AddCaloCluster(const AliESDCaloCluster *c) {
 342     // Add calocluster
 343     TClonesArray &fc = *fCaloClusters;
 344     AliESDCaloCluster *clus = new(fc[fCaloClusters->GetEntriesFast()]) AliESDCaloCluster(*c);
 345     clus->SetID(fCaloClusters->GetEntriesFast()-1);
 346     return fCaloClusters->GetEntriesFast()-1;
 347   }
 348
 349
 350 void AliESD::SetFMDData(AliESDFMD * obj) {
 351   // use already allocated space
 352   if(fESDFMD){
 353     new(fESDFMD) AliESDFMD(*obj);
 354   }
 355 }
 356
 357 void AliESD::SetVZEROData(AliESDVZERO * obj){
 358   // use already allocated space
 359   if(fESDVZERO)
 360     new(fESDVZERO) AliESDVZERO(*obj);
 361 }
 362
 363 void AliESD::GetESDfriend(AliESDfriend *ev) const {
 364   //
 365   // Extracts the complementary info from the ESD
 366   //
 367   if (!ev) return;
 368
 369   Int_t ntrk=GetNumberOfTracks();
 370
 371   for (Int_t i=0; i<ntrk; i++) {
 372     const AliESDtrack *t=GetTrack(i);
 373     const AliESDfriendTrack *f=t->GetFriendTrack();
 374     ev->AddTrack(f);
 375   }
 376 }
 377
 378
 379 void AliESD::AddObject(TObject* obj)
 380 {
 381   // Add an object to the list of object.
 382   // Please be aware that in order to increase performance you should
 383   // refrain from using TObjArrays (if possible). Use TClonesArrays, instead.
 384   fESDObjects->AddLast(obj);
 385 }
 386
 387
 388 void AliESD::GetStdContent()
 389 {
 390   // set pointers for standard content
 391
 392   fESDRun = (AliESDRun*)fESDObjects->At(kESDRun);
 393   fHeader = (AliESDHeader*)fESDObjects->At(kHeader);
 394   fESDZDC = (AliESDZDC*)fESDObjects->At(kESDZDC);
 395   fESDFMD = (AliESDFMD*)fESDObjects->At(kESDFMD);
 396   fESDVZERO = (AliESDVZERO*)fESDObjects->At(kESDVZERO);
 397   fESDTZERO = (AliESDTZERO*)fESDObjects->At(kESDTZERO);
 398   fSPDVertex = (AliESDVertex*)fESDObjects->At(kSPDVertex);
 399   fPrimaryVertex = (AliESDVertex*)fESDObjects->At(kPrimaryVertex);
 400   fSPDMult =       (AliMultiplicity*)fESDObjects->At(kSPDMult);
 401   fPHOSTrigger = (AliESDCaloTrigger*)fESDObjects->At(kPHOSTrigger);
 402   fEMCALTrigger = (AliESDCaloTrigger*)fESDObjects->At(kEMCALTrigger);
 403   fTracks = (TClonesArray*)fESDObjects->At(kTracks);
 404   fMuonTracks = (TClonesArray*)fESDObjects->At(kMuonTracks);
 405   fPmdTracks = (TClonesArray*)fESDObjects->At(kPmdTracks);
 406   fTrdTracks = (TClonesArray*)fESDObjects->At(kTrdTracks);
 407   fV0s = (TClonesArray*)fESDObjects->At(kV0s);
 408   fCascades = (TClonesArray*)fESDObjects->At(kCascades);
 409   fKinks = (TClonesArray*)fESDObjects->At(kKinks);
 410   fCaloClusters = (TClonesArray*)fESDObjects->At(kCaloClusters);
 411   fErrorLogs = (TClonesArray*)fESDObjects->At(kErrorLogs);
 412
 413 }
 414
 415 void AliESD::SetStdNames(){
 416   // Set the names of the standard contents
 417   fSPDVertex->SetName("SPDVertex");
 418   fPrimaryVertex->SetName("PrimaryVertex");
 419   fPHOSTrigger->SetName("PHOSTrigger");
 420   fEMCALTrigger->SetName("EMCALTrigger");
 421   fTracks->SetName("Tracks");
 422   fMuonTracks->SetName("MuonTracks");
 423   fPmdTracks->SetName("PmdTracks");
 424   fTrdTracks->SetName("TrdTracks");
 425   fV0s->SetName("V0s");
 426   fCascades->SetName("Cascades");
 427   fKinks->SetName("Kinks");
 428   fCaloClusters->SetName("CaloClusters");
 429
 430 }
 431
 432 void AliESD::CreateStdContent()
 433 {
 434   // create the standard AOD content and set pointers
 435
 436   // create standard objects and add them to the TList of objects
 437   AddObject(new AliESDRun());
 438   AddObject(new AliESDHeader());
 439   AddObject(new AliESDZDC());
 440   AddObject(new AliESDFMD());
 441   AddObject(new AliESDVZERO());
 442   AddObject(new AliESDTZERO());
 443   AddObject(new AliESDVertex());
 444   AddObject(new AliESDVertex());
 445   AddObject(new AliMultiplicity());
 446   AddObject(new AliESDCaloTrigger());
 447   AddObject(new AliESDCaloTrigger());
 448   AddObject(new TClonesArray("AliESDtrack",0));
 449   AddObject(new TClonesArray("AliESDMuonTrack",0));
 450   AddObject(new TClonesArray("AliESDPmdTrack",0));
 451   AddObject(new TClonesArray("AliESDTrdTrack",0));
 452   AddObject(new TClonesArray("AliESDv0",0));
 453   AddObject(new TClonesArray("AliESDcascade",0));
 454   AddObject(new TClonesArray("AliESDkink",0));
 455   AddObject(new TClonesArray("AliESDCaloCluster",0));
 456   AddObject(new TClonesArray("AliRawDataErrorLog",0));
 457
 458   // check the order of the indices against enum...
 459
 460   // read back pointers
 461   GetStdContent();
 462   // set names
 463   SetStdNames();
 464
 465 }
 466
 467 void AliESD::ReadFromTree(TTree *tree){
 468
 469
 470   // is this really so smart that an ESDObject has a pointer to a list
 471   // of another ESDObject...
 472
 473   fESDObjects = (TList*)((AliESD*)tree->GetTree()->GetUserInfo()->FindObject("AliESD"))->GetList();
 474
 475   if(fESDObjects->GetEntries()<kESDListN){
 476     printf("%s %d AliESD::ReadFromTree() TList contains less than the standard contents %d < %d \n",(char*)__FILE__,__LINE__,fESDObjects->GetEntries(),kESDListN);
 477   }
 478
 479   // if list is empty
 480   // we could still set the branch adresses based on
 481   // tree->GetListOfBranches() CKB
 482   // or create standard list
 483
 484   // set the branch addresses
 485   TIter next(fESDObjects);
 486   TNamed *el;
 487   while((el=(TNamed*)next())){
 488     TString bname(el->GetName());
 489
 490     if(bname.CompareTo("AliESDfriend")==0)
 491       {
 492         // AliESDfriend does not have a name ...
 493       tree->SetBranchStatus("ESDfriend.*",1);
 494       printf("Friend %s\n", bname.Data());
 495       tree->SetBranchAddress("ESDfriend.",fESDObjects->GetObjectRef(el));
 496
 497
 498     }
 499     else{
 500       printf("%s\n", bname.Data());
 501       tree->SetBranchAddress(bname.Data(),fESDObjects->GetObjectRef(el));
 502     }
 503   }
 504
 505   GetStdContent();
 506 }
 507
 508
 509