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
  27
  28 ClassImp(AliESDRun)
  29
  30 //______________________________________________________________________________
  31 AliESDRun::AliESDRun() :
  32   fRunNumber(0),
  33   fPeriodNumber(0),
  34   fRecoVersion(0),
  35   fMagneticField(0)
  36 {
  37   for (Int_t i=0; i<2; i++) fDiamondXY[i]=0.;
  38   for (Int_t i=0; i<3; i++) fDiamondCovXY[i]=0.;
  39 }
  40
  41 //______________________________________________________________________________
  42 AliESDRun::AliESDRun(const AliESDRun &esd) :
  43   TObject(esd),
  44   fRunNumber(esd.fRunNumber),
  45   fPeriodNumber(esd.fPeriodNumber),
  46   fRecoVersion(esd.fRecoVersion),
  47   fMagneticField(esd.fMagneticField)
  48 {
  49   for (Int_t i=0; i<2; i++) fDiamondXY[i]=esd.fDiamondXY[i];
  50   for (Int_t i=0; i<3; i++) fDiamondCovXY[i]=esd.fDiamondCovXY[i];
  51 }
  52
  53 //______________________________________________________________________________
  54 AliESDRun& AliESDRun::operator=(const AliESDRun &esd)
  55 {
  56   if(this!=&esd) {
  57     TObject::operator=(esd);
  58     fRunNumber=esd.fRunNumber;
  59     fPeriodNumber=esd.fPeriodNumber;
  60     fRecoVersion=esd.fRecoVersion;
  61     fMagneticField=esd.fMagneticField;
  62     for (Int_t i=0; i<2; i++) fDiamondXY[i]=esd.fDiamondXY[i];
  63     for (Int_t i=0; i<3; i++) fDiamondCovXY[i]=esd.fDiamondCovXY[i];
  64   }
  65   return *this;
  66 }
  67
  68 //______________________________________________________________________________
  69 void AliESDRun::Print(const Option_t *) const
  70 {
  71   printf("Mean vertex in RUN %d: X=%.4f Y=%.4f cm\n",
  72          GetRunNumber(),GetDiamondX(),GetDiamondY());
  73   printf("Magnetic field = %f T\n",
  74          GetMagneticField());
  75   printf("Event from reconstruction version %d \n",fRecoVersion);
  76 }
  77
  78 void AliESDRun::Reset()
  79 {
  80   fRunNumber = 0;
  81   fPeriodNumber = 0;
  82   fRecoVersion = 0;
  83   fMagneticField = 0;
  84   for (Int_t i=0; i<2; i++) fDiamondXY[i]=0.;
  85   for (Int_t i=0; i<3; i++) fDiamondCovXY[i]=0.;
  86 }
  87
  88 ClassImp(AliESDHeader)
  89
  90 //______________________________________________________________________________
  91 AliESDHeader::AliESDHeader() :
  92   TObject(),
  93   fTriggerMask(0),
  94   fOrbitNumber(0),
  95   fTimeStamp(0),
  96   fEventType(0),
  97   fEventNumberInFile(0),
  98   fBunchCrossNumber(0),
  99   fTriggerCluster(0)
 100 {
 101 }
 102
 103
 104 AliESDHeader::AliESDHeader(const AliESDHeader &header) :
 105   TObject(header),
 106   fTriggerMask(header.fTriggerMask),
 107   fOrbitNumber(header.fOrbitNumber),
 108   fTimeStamp(header.fTimeStamp),
 109   fEventType(header.fEventType),
 110   fEventNumberInFile(header.fEventNumberInFile),
 111   fBunchCrossNumber(header.fBunchCrossNumber),
 112   fTriggerCluster(header.fTriggerCluster)
 113 {
 114 }
 115
 116 AliESDHeader& AliESDHeader::operator=(const AliESDHeader &header)
 117 {
 118   if(this!=&header) {
 119     TObject::operator=(header);
 120     fTriggerMask = header.fTriggerMask;
 121     fOrbitNumber = header.fOrbitNumber;
 122     fTimeStamp = header.fTimeStamp;
 123     fEventType = header.fEventType;
 124     fEventNumberInFile = header.fEventNumberInFile;
 125     fBunchCrossNumber = header.fBunchCrossNumber;
 126     fTriggerCluster = header.fTriggerCluster;
 127   }
 128   return *this;
 129 }
 130
 131
 132
 133 //______________________________________________________________________________
 134 void AliESDHeader::Reset()
 135 {
 136   fTriggerMask       = 0;
 137   fOrbitNumber       = 0;
 138   fTimeStamp         = 0;
 139   fEventType         = 0;
 140   fEventNumberInFile = 0;
 141   fBunchCrossNumber  = 0;
 142   fTriggerCluster    = 0;
 143 }
 144
 145 //______________________________________________________________________________
 146 void AliESDHeader::Print(const Option_t *) const
 147 {
 148   printf("Event # %d in file Bunch crossing # %d Orbit # %d Trigger %lld \n",
 149          GetEventNumberInFile(),
 150          GetBunchCrossNumber(),
 151          GetOrbitNumber(),
 152          GetTriggerMask());
 153 }
 154
 155 ClassImp(AliESDZDC)
 156
 157 //______________________________________________________________________________
 158 AliESDZDC::AliESDZDC() :
 159   TObject(),
 160   fZDCN1Energy(0),
 161   fZDCP1Energy(0),
 162   fZDCN2Energy(0),
 163   fZDCP2Energy(0),
 164   fZDCEMEnergy(0),
 165   fZDCParticipants(0)
 166 {
 167 }
 168
 169 AliESDZDC::AliESDZDC(const AliESDZDC& zdc) :
 170   TObject(zdc),
 171   fZDCN1Energy(zdc.fZDCN1Energy),
 172   fZDCP1Energy(zdc.fZDCP1Energy),
 173   fZDCN2Energy(zdc.fZDCN2Energy),
 174   fZDCP2Energy(zdc.fZDCP2Energy),
 175   fZDCEMEnergy(zdc.fZDCEMEnergy),
 176   fZDCParticipants(zdc.fZDCParticipants)
 177 {
 178 }
 179
 180 AliESDZDC& AliESDZDC::operator=(const AliESDZDC&zdc)
 181 {
 182   if(this!=&zdc) {
 183     TObject::operator=(zdc);
 184     fZDCN1Energy = zdc.fZDCN1Energy;
 185     fZDCP1Energy = zdc.fZDCP1Energy;
 186     fZDCN2Energy = zdc.fZDCN2Energy;
 187     fZDCP2Energy = zdc.fZDCP2Energy;
 188     fZDCEMEnergy = zdc.fZDCEMEnergy;
 189     fZDCParticipants = zdc.fZDCParticipants;
 190   }
 191   return *this;
 192 }
 193
 194
 195 //______________________________________________________________________________
 196 void AliESDZDC::Reset()
 197 {
 198   fZDCN1Energy=0;
 199   fZDCP1Energy=0;
 200   fZDCN2Energy=0;
 201   fZDCP2Energy=0;
 202   fZDCEMEnergy=0;
 203   fZDCParticipants=0;
 204 }
 205
 206 //______________________________________________________________________________
 207 void AliESDZDC::Print(const Option_t *) const
 208 {
 209 }
 210
 211
 212 ClassImp(AliESDTZERO)
 213
 214 //______________________________________________________________________________
 215 AliESDTZERO::AliESDTZERO() :
 216   TObject(),
 217   fT0zVertex(0),
 218   fT0timeStart(0)
 219 {
 220   for(int i = 0;i<24;i++)fT0time[i] = fT0amplitude[i] = 0;
 221 }
 222
 223 AliESDTZERO::AliESDTZERO(const AliESDTZERO &tzero ) :
 224   TObject(tzero),
 225   fT0zVertex(tzero.fT0zVertex),
 226   fT0timeStart(tzero.fT0timeStart)
 227 {
 228   for(int i = 0;i<24;i++){
 229     fT0time[i] = tzero.fT0time[i];
 230     fT0amplitude[i] = tzero.fT0amplitude[i];
 231   }
 232 }
 233
 234 AliESDTZERO& AliESDTZERO::operator=(const AliESDTZERO& tzero){
 235   if(this!=&tzero) {
 236     TObject::operator=(tzero);
 237     fT0zVertex = tzero.fT0zVertex;
 238     fT0timeStart = tzero.fT0timeStart;
 239     for(int i = 0;i<24;i++){
 240       fT0time[i] = tzero.fT0time[i];
 241       fT0amplitude[i] = tzero.fT0amplitude[i];
 242     }
 243   }
 244   return *this;
 245 }
 246
 247 //______________________________________________________________________________
 248 void AliESDTZERO::Reset()
 249 {
 250   fT0zVertex = 0;
 251   fT0timeStart = 0;
 252   for(int i = 0;i<24;i++)fT0time[i] = fT0amplitude[i] = 0;
 253 }
 254
 255 //______________________________________________________________________________
 256 void AliESDTZERO::Print(const Option_t *) const
 257 {
 258 }
 259
 260 ClassImp(AliESDCaloTrigger)
 261
 262 AliESDCaloTrigger::AliESDCaloTrigger() :
 263   TNamed(),
 264   fTriggerAmplitudes(0x0),
 265   fTriggerPosition(0x0)
 266 {
 267 }
 268
 269 AliESDCaloTrigger::AliESDCaloTrigger(const AliESDCaloTrigger &ctrig) :
 270   TNamed(ctrig),
 271   fTriggerAmplitudes(ctrig.fTriggerAmplitudes),
 272   fTriggerPosition(ctrig.fTriggerPosition)
 273 {
 274 }
 275
 276 AliESDCaloTrigger::~AliESDCaloTrigger()
 277 {
 278   delete fTriggerAmplitudes; fTriggerAmplitudes = 0;
 279   delete fTriggerPosition; fTriggerPosition = 0;
 280 }
 281
 282 AliESDCaloTrigger& AliESDCaloTrigger::operator=(const AliESDCaloTrigger& ctrig)
 283 {
 284   if(this!=&ctrig) {
 285     TNamed::operator=(ctrig);
 286     // CKB dont't want to create leak if fTriggerAmp points to
 287     // somthing already, use new with placement
 288     if(fTriggerAmplitudes){
 289       fTriggerAmplitudes = new(fTriggerAmplitudes) TArrayF(*ctrig.fTriggerAmplitudes);
 290     }
 291     else{
 292       fTriggerAmplitudes = new TArrayF(*ctrig.fTriggerAmplitudes);
 293     }
 294     if(fTriggerPosition){
 295       fTriggerPosition = new(fTriggerPosition) TArrayF(*ctrig.fTriggerPosition);
 296     }
 297     else{
 298       fTriggerPosition = new TArrayF(*ctrig.fTriggerPosition);
 299     }
 300   }
 301   return *this;
 302 }
 303
 304 void AliESDCaloTrigger::Reset()
 305 {
 306
 307   if( fTriggerAmplitudes){
 308     printf("%s %d Size %d",(char*)__FILE__,__LINE__,fTriggerAmplitudes->GetSize());
 309     fTriggerAmplitudes->Reset();
 310 // delete fTriggerAmplitudes;
 311   }
 312   if( fTriggerPosition){
 313     fTriggerPosition->Reset();
 314   // delete fTriggerPosition;
 315   }
 316 }
 317
 318
 319
 320 ClassImp(AliESD)
 321
 322 //______________________________________________________________________________
 323 AliESD::AliESD():
 324   fESDObjects(new TList()),
 325   fESDRun(0),
 326   fHeader(0),
 327   fESDZDC(0),
 328   fESDFMD(0),
 329   fESDVZERO(0),
 330   fESDTZERO(0),
 331   fSPDVertex(0),
 332   fPrimaryVertex(0),
 333   fSPDMult(0),
 334   fPHOSTrigger(0),
 335   fEMCALTrigger(0),
 336   fTracks(0),
 337   fMuonTracks(0),
 338   fPmdTracks(0),
 339   fTrdTracks(0),
 340   fV0s(0),
 341   fCascades(0),
 342   fKinks(0),
 343   fCaloClusters(0),
 344   fErrorLogs(0),
 345   fEMCALClusters(0),
 346   fFirstEMCALCluster(-1),
 347   fPHOSClusters(0),
 348   fFirstPHOSCluster(-1)
 349 {
 350 }
 351 //______________________________________________________________________________
 352 AliESD::AliESD(const AliESD& esd):
 353   TObject(esd),
 354   fESDObjects(new TList()),
 355   fESDRun(new AliESDRun(*esd.fESDRun)),
 356   fHeader(new AliESDHeader(*esd.fHeader)),
 357   fESDZDC(new AliESDZDC(*esd.fESDZDC)),
 358   fESDFMD(new AliESDFMD(*esd.fESDFMD)),
 359   fESDVZERO(new AliESDVZERO(*esd.fESDVZERO)),
 360   fESDTZERO(new AliESDTZERO(*esd.fESDTZERO)),
 361   fSPDVertex(new AliESDVertex(*esd.fSPDVertex)),
 362   fPrimaryVertex(new AliESDVertex(*esd.fPrimaryVertex)),
 363   fSPDMult(new AliMultiplicity(*esd.fSPDMult)),
 364   fPHOSTrigger(new AliESDCaloTrigger(*esd.fPHOSTrigger)),
 365   fEMCALTrigger(new AliESDCaloTrigger(*esd.fEMCALTrigger)),
 366   fTracks(new TClonesArray(*esd.fTracks)),
 367   fMuonTracks(new TClonesArray(*esd.fMuonTracks)),
 368   fPmdTracks(new TClonesArray(*esd.fPmdTracks)),
 369   fTrdTracks(new TClonesArray(*esd.fTrdTracks)),
 370   fV0s(new TClonesArray(*esd.fV0s)),
 371   fCascades(new TClonesArray(*esd.fCascades)),
 372   fKinks(new TClonesArray(*esd.fKinks)),
 373   fCaloClusters(new TClonesArray(*esd.fCaloClusters)),
 374   fErrorLogs(new TClonesArray(*esd.fErrorLogs)),
 375   fEMCALClusters(esd.fEMCALClusters),
 376   fFirstEMCALCluster(esd.fFirstEMCALCluster),
 377   fPHOSClusters(esd.fPHOSClusters),
 378   fFirstPHOSCluster(esd.fFirstPHOSCluster)
 379
 380 {
 381   // CKB init in the constructor list and only add here ...
 382   AddObject(fESDRun);
 383   AddObject(fHeader);
 384   AddObject(fESDZDC);
 385   AddObject(fESDFMD);
 386   AddObject(fESDVZERO);
 387   AddObject(fESDTZERO);
 388   AddObject(fSPDVertex);
 389   AddObject(fPrimaryVertex);
 390   AddObject(fSPDMult);
 391   AddObject(fPHOSTrigger);
 392   AddObject(fEMCALTrigger);
 393   AddObject(fTracks);
 394   AddObject(fMuonTracks);
 395   AddObject(fPmdTracks);
 396   AddObject(fTrdTracks);
 397   AddObject(fV0s);
 398   AddObject(fCascades);
 399   AddObject(fKinks);
 400   AddObject(fCaloClusters);
 401   AddObject(fErrorLogs);
 402
 403   GetStdContent();
 404
 405 }
 406
 407 //______________________________________________________________________________
 408 AliESD & AliESD::operator=(const AliESD& source) {
 409
 410   // Assignment operator
 411
 412   if(&source == this) return *this;
 413   TObject::operator=(source);
 414
 415   fESDRun = new AliESDRun(*source.fESDRun);
 416   fHeader = new AliESDHeader(*source.fHeader);
 417   fESDZDC = new AliESDZDC(*source.fESDZDC);
 418   fESDFMD = new AliESDFMD(*source.fESDFMD);
 419   fESDVZERO = new AliESDVZERO(*source.fESDVZERO);
 420   fESDTZERO = new AliESDTZERO(*source.fESDTZERO);
 421   fSPDVertex = new AliESDVertex(*source.fSPDVertex);
 422   fPrimaryVertex = new AliESDVertex(*source.fPrimaryVertex);
 423   fSPDMult = new AliMultiplicity(*source.fSPDMult);
 424   fPHOSTrigger = new AliESDCaloTrigger(*source.fPHOSTrigger);
 425   fEMCALTrigger = new AliESDCaloTrigger(*source.fEMCALTrigger);
 426   fTracks = new TClonesArray(*source.fTracks);
 427   fMuonTracks = new TClonesArray(*source.fMuonTracks);
 428   fPmdTracks = new TClonesArray(*source.fPmdTracks);
 429   fTrdTracks = new TClonesArray(*source.fTrdTracks);
 430   fV0s = new TClonesArray(*source.fV0s);
 431   fCascades = new TClonesArray(*source.fCascades);
 432   fKinks = new TClonesArray(*source.fKinks);
 433   fCaloClusters = new TClonesArray(*source.fCaloClusters);
 434   fErrorLogs = new TClonesArray(*source.fErrorLogs);
 435
 436   // CKB this way?? or
 437   // or AddObject(  fESDZDC = new AliESDZDC(*source.fESDZDC));
 438
 439   fESDObjects = new TList();
 440   AddObject(fESDRun);
 441   AddObject(fHeader);
 442   AddObject(fESDZDC);
 443   AddObject(fESDFMD);
 444   AddObject(fESDVZERO);
 445   AddObject(fESDTZERO);
 446   AddObject(fSPDVertex);
 447   AddObject(fPrimaryVertex);
 448   AddObject(fSPDMult);
 449   AddObject(fPHOSTrigger);
 450   AddObject(fEMCALTrigger);
 451   AddObject(fTracks);
 452   AddObject(fMuonTracks);
 453   AddObject(fPmdTracks);
 454   AddObject(fTrdTracks);
 455   AddObject(fV0s);
 456   AddObject(fCascades);
 457   AddObject(fKinks);
 458   AddObject(fCaloClusters);
 459   AddObject(fErrorLogs);
 460
 461
 462   fEMCALClusters = source.fEMCALClusters;
 463   fFirstEMCALCluster = source.fFirstEMCALCluster;
 464   fPHOSClusters = source.fPHOSClusters;
 465   fFirstPHOSCluster = source.fFirstPHOSCluster;
 466
 467
 468
 469   return *this;
 470
 471 }
 472
 473
 474 //______________________________________________________________________________
 475 AliESD::~AliESD()
 476 {
 477   //
 478   // Standard destructor
 479   //
 480
 481   delete fESDObjects;
 482   fESDObjects = 0;
 483
 484   // everthing on the list gets deleted automatically
 485
 486   /*
 487   fHLTConfMapTracks.Delete();
 488   fHLTHoughTracks.Delete();
 489   fMuonTracks.Delete();
 490   fPmdTracks.Delete();
 491   fTrdTracks.Delete();
 492   fV0s.Delete();
 493   fCascades.Delete();
 494   fKinks.Delete();
 495   fCaloClusters.Delete();
 496   */
 497 //   fEMCALTriggerPosition->Delete();
 498 //   fEMCALTriggerAmplitudes->Delete();
 499 //   fPHOSTriggerPosition->Delete();
 500 //   fPHOSTriggerAmplitudes->Delete();
 501 //   delete fEMCALTriggerPosition;
 502 //   delete fEMCALTriggerAmplitudes;
 503 //   delete fPHOSTriggerPosition;
 504 //   delete fPHOSTriggerAmplitudes;
 505
 506 }
 507
 508 //______________________________________________________________________________
 509 void AliESD::Reset()
 510 {
 511
 512   if(fESDRun) fESDRun->Reset();
 513   if(fHeader) fHeader->Reset();
 514   if(fESDZDC) fESDZDC->Reset();
 515   if(fESDFMD) fESDFMD->Clear(); // why clear.... need consistend names
 516   // if(fESDVZERO) fESDVZERO->; // NOT IMPLEMENTED
 517   //  if(fESDVZERO) new (fESDVZERO) AliESDVZERO();
 518   if(fESDTZERO) fESDTZERO->Reset();
 519   // CKB no clear/reset implemented
 520   if(fSPDVertex){
 521     new (fSPDVertex) AliESDVertex();
 522     fSPDVertex->SetName("SPDVertex");
 523   }
 524   if(fPrimaryVertex){
 525     new (fPrimaryVertex) AliESDVertex();
 526     fPrimaryVertex->SetName("PrimaryVertex");
 527   }
 528   if(fSPDMult)new (fSPDMult) AliMultiplicity();
 529   if(fPHOSTrigger)fPHOSTrigger->Reset();
 530   if(fEMCALTrigger)fEMCALTrigger->Reset();
 531   if(fTracks)fTracks->Clear();
 532   if(fMuonTracks)fMuonTracks->Clear();
 533   if(fPmdTracks)fPmdTracks->Clear();
 534   if(fTrdTracks)fTrdTracks->Clear();
 535   if(fV0s)fV0s->Clear();
 536   if(fCascades)fCascades->Clear();
 537   if(fKinks)fKinks->Clear();
 538   if(fCaloClusters)fCaloClusters->Clear();
 539   if(fErrorLogs) fErrorLogs->Clear();
 540
 541
 542   fEMCALClusters=0;
 543   fFirstEMCALCluster=-1;
 544   fPHOSClusters=0;
 545   fFirstPHOSCluster=-1;
 546 }
 547
 548 Int_t AliESD::AddV0(const AliESDv0 *v) {
 549   //
 550   // Add V0
 551   //
 552   TClonesArray &fv = *fV0s;
 553   Int_t idx=fV0s->GetEntriesFast();
 554   new(fv[idx]) AliESDv0(*v);
 555   return idx;
 556 }
 557
 558 //______________________________________________________________________________
 559 void AliESD::Print(Option_t *) const
 560 {
 561   //
 562   // Print header information of the event
 563   //
 564   printf("ESD run information\n");
 565   printf("Event # in file %d Bunch crossing # %d Orbit # %d Period # %d Run # %d Trigger %lld Magnetic field %f \n",
 566          GetEventNumberInFile(),
 567          GetBunchCrossNumber(),
 568          GetOrbitNumber(),
 569          GetPeriodNumber(),
 570          GetRunNumber(),
 571          GetTriggerMask(),
 572          GetMagneticField() );
 573   printf("Vertex: (%.4f +- %.4f, %.4f +- %.4f, %.4f +- %.4f) cm\n",
 574            fPrimaryVertex->GetXv(), fPrimaryVertex->GetXRes(),
 575            fPrimaryVertex->GetYv(), fPrimaryVertex->GetYRes(),
 576            fPrimaryVertex->GetZv(), fPrimaryVertex->GetZRes());
 577     printf("Mean vertex in RUN: X=%.4f Y=%.4f cm\n",
 578            GetDiamondX(),GetDiamondY());
 579     printf("SPD Multiplicity. Number of tracklets %d \n",
 580            fSPDMult->GetNumberOfTracklets());
 581   printf("Number of tracks: \n");
 582   printf("                 charged   %d\n", GetNumberOfTracks());
 583   printf("                 muon      %d\n", GetNumberOfMuonTracks());
 584   printf("                 pmd       %d\n", GetNumberOfPmdTracks());
 585   printf("                 trd       %d\n", GetNumberOfTrdTracks());
 586   printf("                 v0        %d\n", GetNumberOfV0s());
 587   printf("                 cascades  %d\n", GetNumberOfCascades());
 588   printf("                 kinks     %d\n", GetNumberOfKinks());
 589   printf("                 CaloClusters %d\n", GetNumberOfCaloClusters());
 590   printf("                 phos      %d\n", GetNumberOfPHOSClusters());
 591   printf("                 emcal     %d\n", GetNumberOfEMCALClusters());
 592   printf("                 FMD       %s\n", (fESDFMD ? "yes" : "no"));
 593   printf("                 VZERO     %s\n", (fESDVZERO ? "yes" : "no"));
 594 }
 595
 596 void AliESD::SetESDfriend(const AliESDfriend *ev) {
 597   //
 598   // Attaches the complementary info to the ESD
 599   //
 600   if (!ev) return;
 601
 602   Int_t ntrk=ev->GetNumberOfTracks();
 603
 604   for (Int_t i=0; i<ntrk; i++) {
 605     const AliESDfriendTrack *f=ev->GetTrack(i);
 606     GetTrack(i)->SetFriendTrack(f);
 607   }
 608 }
 609
 610 void AliESD::GetESDfriend(AliESDfriend *ev) const {
 611   //
 612   // Extracts the complementary info from the ESD
 613   //
 614   if (!ev) return;
 615
 616   Int_t ntrk=GetNumberOfTracks();
 617
 618   for (Int_t i=0; i<ntrk; i++) {
 619     const AliESDtrack *t=GetTrack(i);
 620     const AliESDfriendTrack *f=t->GetFriendTrack();
 621     ev->AddTrack(f);
 622   }
 623 }
 624
 625 void AliESD::AddObject(TObject* obj)
 626 {
 627   // Add an object to the list of object.
 628   // Please be aware that in order to increase performance you should
 629   // refrain from using TObjArrays (if possible). Use TClonesArrays, instead.
 630   fESDObjects->AddLast(obj);
 631 }
 632
 633 void AliESD::GetStdContent()
 634 {
 635   // set pointers for standard content
 636
 637   fESDRun = (AliESDRun*)fESDObjects->At(kESDRun);
 638   fHeader = (AliESDHeader*)fESDObjects->At(kHeader);
 639   fESDZDC = (AliESDZDC*)fESDObjects->At(kESDZDC);
 640   fESDFMD = (AliESDFMD*)fESDObjects->At(kESDFMD);
 641   fESDVZERO = (AliESDVZERO*)fESDObjects->At(kESDVZERO);
 642   fESDTZERO = (AliESDTZERO*)fESDObjects->At(kESDTZERO);
 643   fSPDVertex = (AliESDVertex*)fESDObjects->At(kSPDVertex);
 644   fPrimaryVertex = (AliESDVertex*)fESDObjects->At(kPrimaryVertex);
 645   fSPDMult =       (AliMultiplicity*)fESDObjects->At(kSPDMult);
 646   fPHOSTrigger = (AliESDCaloTrigger*)fESDObjects->At(kPHOSTrigger);
 647   fEMCALTrigger = (AliESDCaloTrigger*)fESDObjects->At(kEMCALTrigger);
 648   fTracks = (TClonesArray*)fESDObjects->At(kTracks);
 649   fMuonTracks = (TClonesArray*)fESDObjects->At(kMuonTracks);
 650   fPmdTracks = (TClonesArray*)fESDObjects->At(kPmdTracks);
 651   fTrdTracks = (TClonesArray*)fESDObjects->At(kTrdTracks);
 652   fV0s = (TClonesArray*)fESDObjects->At(kV0s);
 653   fCascades = (TClonesArray*)fESDObjects->At(kCascades);
 654   fKinks = (TClonesArray*)fESDObjects->At(kKinks);
 655   fCaloClusters = (TClonesArray*)fESDObjects->At(kCaloClusters);
 656   fErrorLogs = (TClonesArray*)fESDObjects->At(kErrorLogs);
 657
 658 }
 659
 660 void AliESD::SetStdNames(){
 661
 662   fSPDVertex->SetName("SPDVertex");
 663   fPrimaryVertex->SetName("PrimaryVertex");
 664   fPHOSTrigger->SetName("PHOSTrigger");
 665   fEMCALTrigger->SetName("EMCALTrigger");
 666   fTracks->SetName("Tracks");
 667   fMuonTracks->SetName("MuonTracks");
 668   fPmdTracks->SetName("PmdTracks");
 669   fTrdTracks->SetName("TrdTracks");
 670   fV0s->SetName("V0s");
 671   fCascades->SetName("Cascades");
 672   fKinks->SetName("Kinks");
 673   fCaloClusters->SetName("CaloClusters");
 674
 675 }
 676
 677 void AliESD::CreateStdContent()
 678 {
 679   // create the standard AOD content and set pointers
 680
 681   // create standard objects and add them to the TList of objects
 682   AddObject(new AliESDRun());
 683   AddObject(new AliESDHeader());
 684   AddObject(new AliESDZDC());
 685   AddObject(new AliESDFMD());
 686   AddObject(new AliESDVZERO());
 687   AddObject(new AliESDTZERO());
 688   AddObject(new AliESDVertex());
 689   AddObject(new AliESDVertex());
 690   AddObject(new AliMultiplicity());
 691   AddObject(new AliESDCaloTrigger());
 692   AddObject(new AliESDCaloTrigger());
 693   AddObject(new TClonesArray("AliESDtrack",0));
 694   AddObject(new TClonesArray("AliESDMuonTrack",0));
 695   AddObject(new TClonesArray("AliESDPmdTrack",0));
 696   AddObject(new TClonesArray("AliESDTrdTrack",0));
 697   AddObject(new TClonesArray("AliESDv0",0));
 698   AddObject(new TClonesArray("AliESDcascade",0));
 699   AddObject(new TClonesArray("AliESDkink",0));
 700   AddObject(new TClonesArray("AliESDCaloCluster",0));
 701   AddObject(new TClonesArray("AliRawDataErrorLog",0));
 702
 703   // check the order of the indices against enum...
 704
 705   // read back pointers
 706   GetStdContent();
 707   // set names
 708   SetStdNames();
 709
 710 }
 711
 712 void AliESD::ReadFromTree(TTree *tree){
 713
 714
 715   // is this really so smart that an ESDObject has a pointer to a list
 716   // of another ESDObject...
 717
 718   fESDObjects = (TList*)((AliESD*)tree->GetTree()->GetUserInfo()->FindObject("AliESD"))->GetList();
 719
 720   if(fESDObjects->GetEntries()<kESDListN){
 721     printf("%s %d AliESD::ReadFromTree() TList contains less than the standard contents %d < %d \n",(char*)__FILE__,__LINE__,fESDObjects->GetEntries(),kESDListN);
 722   }
 723
 724   // if list is empty
 725   // we could still set the branch adresses based on
 726   // tree->GetListOfBranches() CKB
 727   // or create standard list
 728
 729   // set the branch addresses
 730   TIter next(fESDObjects);
 731   TNamed *el;
 732   while((el=(TNamed*)next())){
 733     TString bname(el->GetName());
 734
 735     if(bname.CompareTo("AliESDfriend")==0)
 736       {
 737         // AliESDfriend does not have a name ...
 738       tree->SetBranchStatus("ESDfriend.*",1);
 739       printf("Friend %s\n", bname.Data());
 740       tree->SetBranchAddress("ESDfriend.",fESDObjects->GetObjectRef(el));
 741
 742
 743     }
 744     else{
 745       printf("%s\n", bname.Data());
 746       tree->SetBranchAddress(bname.Data(),fESDObjects->GetObjectRef(el));
 747     }
 748   }
 749
 750   GetStdContent();
 751 }
 752
 753
 754