STEER/ESD/AliESDEvent.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: AliESDEvent.cxx 64008 2013-08-28 13:09:59Z hristov $ */
  17
  18 //-----------------------------------------------------------------
  19 //           Implementation of the AliESDEvent class
  20 //   This is the class to deal with during the physics analysis of data.
  21 //   It also ensures the backward compatibility with the old ESD format.
  22 /*
  23    AliESDEvent *ev= new AliESDEvent();
  24    ev->ReadFromTree(esdTree);
  25    ...
  26     for (Int_t i=0; i<nev; i++) {
  27       esdTree->GetEntry(i);
  28       if(ev->GetAliESDOld())ev->CopyFromOldESD();
  29 */
  30 //   The AliESDInputHandler does this automatically for you
  31 //
  32 // Origin: Christian Klein-Boesing, CERN, Christian.Klein-Boesing@cern.ch
  33 //-----------------------------------------------------------------
  34
  35 #include "TList.h"
  36 #include "TRefArray.h"
  37 #include <TNamed.h>
  38 #include <TROOT.h>
  39 #include <TInterpreter.h>
  40
  41 #include "AliESDEvent.h"
  42 #include "AliESDfriend.h"
  43 #include "AliESDVZERO.h"
  44 #include "AliESDFMD.h"
  45 #include "AliESD.h"
  46 #include "AliESDMuonTrack.h"
  47 #include "AliESDMuonCluster.h"
  48 #include "AliESDMuonPad.h"
  49 #include "AliESDMuonGlobalTrack.h"       // AU
  50 #include "AliESDPmdTrack.h"
  51 #include "AliESDTrdTrack.h"
  52 #include "AliESDVertex.h"
  53 #include "AliESDcascade.h"
  54 #include "AliESDPmdTrack.h"
  55 #include "AliESDTrdTrigger.h"
  56 #include "AliESDTrdTrack.h"
  57 #include "AliESDTrdTracklet.h"
  58 #include "AliESDVertex.h"
  59 #include "AliVertexerTracks.h"
  60 #include "AliESDcascade.h"
  61 #include "AliESDkink.h"
  62 #include "AliESDtrack.h"
  63 #include "AliESDHLTtrack.h"
  64 #include "AliESDCaloCluster.h"
  65 #include "AliESDCaloCells.h"
  66 #include "AliESDv0.h"
  67 #include "AliESDFMD.h"
  68 #include "AliESDVZERO.h"
  69 #include "AliMultiplicity.h"
  70 #include "AliRawDataErrorLog.h"
  71 #include "AliLog.h"
  72 #include "AliESDACORDE.h"
  73 #include "AliESDAD.h"
  74 #include "AliESDHLTDecision.h"
  75 #include "AliCentrality.h"
  76 #include "AliESDCosmicTrack.h"
  77 #include "AliTriggerConfiguration.h"
  78 #include "AliTriggerClass.h"
  79 #include "AliTriggerCluster.h"
  80 #include "AliEventplane.h"
  81
  82 ClassImp(AliESDEvent)
  83
  84 // here we define the names, some classes are no TNamed, therefore the classnames
  85 // are the Names
  86   const char* AliESDEvent::fgkESDListName[kESDListN] = {"AliESDRun",
  87                                                         "AliESDHeader",
  88                                                         "AliESDZDC",
  89                                                         "AliESDFMD",
  90                                                         "AliESDVZERO",
  91                                                         "AliESDTZERO",
  92                                                         "TPCVertex",
  93                                                         "SPDVertex",
  94                                                         "PrimaryVertex",
  95                                                         "AliMultiplicity",
  96                                                         "PHOSTrigger",
  97                                                         "EMCALTrigger",
  98                                                         "SPDPileupVertices",
  99                                                         "TrkPileupVertices",
 100                                                         "Tracks",
 101                                                         "MuonTracks",
 102                                                         "MuonClusters",
 103                                                         "MuonPads",
 104                                                         "MuonGlobalTracks",      // AU
 105                                                         "PmdTracks",
 106                                                         "AliESDTrdTrigger",
 107                                                         "TrdTracks",
 108                                                         "TrdTracklets",
 109                                                         "V0s",
 110                                                         "Cascades",
 111                                                         "Kinks",
 112                                                         "CaloClusters",
 113                                                         "EMCALCells",
 114                                                         "PHOSCells",
 115                                                         "AliRawDataErrorLogs",
 116                                                         "AliESDACORDE",
 117                                                         "AliESDAD",
 118                                                         "AliTOFHeader",
 119                                                         "CosmicTracks",
 120                                                         "AliESDTOFCluster",
 121                                                         "AliESDTOFHit",
 122                                                         "AliESDTOFMatch"};
 123
 124
 125 //______________________________________________________________________________
 126 AliESDEvent::AliESDEvent():
 127   AliVEvent(),
 128   fESDObjects(new TList()),
 129   fESDRun(0),
 130   fHeader(0),
 131   fESDZDC(0),
 132   fESDFMD(0),
 133   fESDVZERO(0),
 134   fESDTZERO(0),
 135   fTPCVertex(0),
 136   fSPDVertex(0),
 137   fPrimaryVertex(0),
 138   fSPDMult(0),
 139   fPHOSTrigger(0),
 140   fEMCALTrigger(0),
 141   fESDACORDE(0),
 142   fESDAD(0),
 143   fTrdTrigger(0),
 144   fSPDPileupVertices(0),
 145   fTrkPileupVertices(0),
 146   fTracks(0),
 147   fMuonTracks(0),
 148   fMuonClusters(0),
 149   fMuonPads(0),
 150   fMuonGlobalTracks(0),    // AU
 151   fPmdTracks(0),
 152   fTrdTracks(0),
 153   fTrdTracklets(0),
 154   fV0s(0),
 155   fCascades(0),
 156   fKinks(0),
 157   fCaloClusters(0),
 158   fEMCALCells(0), fPHOSCells(0),
 159   fCosmicTracks(0),
 160   fESDTOFClusters(0),
 161   fESDTOFHits(0),
 162   fESDTOFMatches(0),
 163   fErrorLogs(0),
 164   fOldMuonStructure(kFALSE),
 165   fESDOld(0),
 166   fESDFriendOld(0),
 167   fConnected(kFALSE),
 168   fUseOwnList(kFALSE),
 169   fTracksConnected(kFALSE),
 170   fTOFHeader(0),
 171   fCentrality(0),
 172   fEventplane(0),
 173   fDetectorStatus(0xFFFFFFFF),
 174   fDAQDetectorPattern(0xFFFF),
 175   fDAQAttributes(0xFFFF)
 176 {
 177 }
 178 //______________________________________________________________________________
 179 AliESDEvent::AliESDEvent(const AliESDEvent& esd):
 180   AliVEvent(esd),
 181   fESDObjects(new TList()),
 182   fESDRun(new AliESDRun(*esd.fESDRun)),
 183   fHeader(new AliESDHeader(*esd.fHeader)),
 184   fESDZDC(new AliESDZDC(*esd.fESDZDC)),
 185   fESDFMD(new AliESDFMD(*esd.fESDFMD)),
 186   fESDVZERO(new AliESDVZERO(*esd.fESDVZERO)),
 187   fESDTZERO(new AliESDTZERO(*esd.fESDTZERO)),
 188   fTPCVertex(new AliESDVertex(*esd.fTPCVertex)),
 189   fSPDVertex(new AliESDVertex(*esd.fSPDVertex)),
 190   fPrimaryVertex(new AliESDVertex(*esd.fPrimaryVertex)),
 191   fSPDMult(new AliMultiplicity(*esd.fSPDMult)),
 192   fPHOSTrigger(new AliESDCaloTrigger(*esd.fPHOSTrigger)),
 193   fEMCALTrigger(new AliESDCaloTrigger(*esd.fEMCALTrigger)),
 194   fESDACORDE(new AliESDACORDE(*esd.fESDACORDE)),
 195   fESDAD(new AliESDAD(*esd.fESDAD)),
 196   fTrdTrigger(new AliESDTrdTrigger(*esd.fTrdTrigger)),
 197   fSPDPileupVertices(new TClonesArray(*esd.fSPDPileupVertices)),
 198   fTrkPileupVertices(new TClonesArray(*esd.fTrkPileupVertices)),
 199   fTracks(new TClonesArray(*esd.fTracks)),
 200   fMuonTracks(new TClonesArray(*esd.fMuonTracks)),
 201   fMuonClusters(new TClonesArray(*esd.fMuonClusters)),
 202   fMuonPads(new TClonesArray(*esd.fMuonPads)),
 203   fMuonGlobalTracks(new TClonesArray(*esd.fMuonGlobalTracks)),     // AU
 204   fPmdTracks(new TClonesArray(*esd.fPmdTracks)),
 205   fTrdTracks(new TClonesArray(*esd.fTrdTracks)),
 206   fTrdTracklets(new TClonesArray(*esd.fTrdTracklets)),
 207   fV0s(new TClonesArray(*esd.fV0s)),
 208   fCascades(new TClonesArray(*esd.fCascades)),
 209   fKinks(new TClonesArray(*esd.fKinks)),
 210   fCaloClusters(new TClonesArray(*esd.fCaloClusters)),
 211   fEMCALCells(new AliESDCaloCells(*esd.fEMCALCells)),
 212   fPHOSCells(new AliESDCaloCells(*esd.fPHOSCells)),
 213   fCosmicTracks(new TClonesArray(*esd.fCosmicTracks)),
 214   fESDTOFClusters(esd.fESDTOFClusters ? new TClonesArray(*esd.fESDTOFClusters) : 0),
 215   fESDTOFHits(esd.fESDTOFHits ? new TClonesArray(*esd.fESDTOFHits) : 0),
 216   fESDTOFMatches(esd.fESDTOFMatches ? new TClonesArray(*esd.fESDTOFMatches) : 0),
 217   fErrorLogs(new TClonesArray(*esd.fErrorLogs)),
 218   fOldMuonStructure(esd.fOldMuonStructure),
 219   fESDOld(esd.fESDOld ? new AliESD(*esd.fESDOld) : 0),
 220   fESDFriendOld(esd.fESDFriendOld ? new AliESDfriend(*esd.fESDFriendOld) : 0),
 221   fConnected(esd.fConnected),
 222   fUseOwnList(esd.fUseOwnList),
 223   fTracksConnected(kFALSE),
 224   fTOFHeader(new AliTOFHeader(*esd.fTOFHeader)),
 225   fCentrality(new AliCentrality(*esd.fCentrality)),
 226   fEventplane(new AliEventplane(*esd.fEventplane)),
 227   fDetectorStatus(esd.fDetectorStatus),
 228   fDAQDetectorPattern(esd.fDAQDetectorPattern),
 229   fDAQAttributes(esd.fDAQAttributes)
 230 {
 231   printf("copying ESD event...\n");   // AU
 232   // CKB init in the constructor list and only add here ...
 233   AddObject(fESDRun);
 234   AddObject(fHeader);
 235   AddObject(fESDZDC);
 236   AddObject(fESDFMD);
 237   AddObject(fESDVZERO);
 238   AddObject(fESDTZERO);
 239   AddObject(fTPCVertex);
 240   AddObject(fSPDVertex);
 241   AddObject(fPrimaryVertex);
 242   AddObject(fSPDMult);
 243   AddObject(fPHOSTrigger);
 244   AddObject(fEMCALTrigger);
 245   AddObject(fTrdTrigger);
 246   AddObject(fSPDPileupVertices);
 247   AddObject(fTrkPileupVertices);
 248   AddObject(fTracks);
 249   AddObject(fMuonTracks);
 250   AddObject(fMuonGlobalTracks);    // AU
 251   AddObject(fPmdTracks);
 252   AddObject(fTrdTracks);
 253   AddObject(fTrdTracklets);
 254   AddObject(fV0s);
 255   AddObject(fCascades);
 256   AddObject(fKinks);
 257   AddObject(fCaloClusters);
 258   AddObject(fEMCALCells);
 259   AddObject(fPHOSCells);
 260   AddObject(fCosmicTracks);
 261   AddObject(fESDTOFClusters);
 262   AddObject(fESDTOFHits);
 263   AddObject(fESDTOFMatches);
 264   AddObject(fErrorLogs);
 265   AddObject(fESDACORDE);
 266   AddObject(fESDAD);
 267   AddObject(fTOFHeader);
 268   AddObject(fMuonClusters);
 269   AddObject(fMuonPads);
 270   GetStdContent();
 271   ConnectTracks();
 272 }
 273
 274 //______________________________________________________________________________
 275 AliESDEvent & AliESDEvent::operator=(const AliESDEvent& source) {
 276
 277   // Assignment operator
 278   printf("operator = ESD\n");
 279   if(&source == this) return *this;
 280   AliVEvent::operator=(source);
 281
 282   // This assumes that the list is already created
 283   // and that the virtual void Copy(Tobject&) function
 284   // is correctly implemented in the derived class
 285   // otherwise only TObject::Copy() will be used
 286
 287
 288
 289   if((fESDObjects->GetSize()==0)&&(source.fESDObjects->GetSize()>=kESDListN)){
 290     // We cover the case that we do not yet have the
 291     // standard content but the source has it
 292     CreateStdContent();
 293   }
 294
 295   TIter next(source.GetList());
 296   TObject *its = 0;
 297   TString name;
 298   while ((its = next())) {
 299     name.Form("%s", its->GetName());
 300     TObject *mine = fESDObjects->FindObject(name.Data());
 301     if(!mine){
 302       TClass* pClass=TClass::GetClass(its->ClassName());
 303       if (!pClass) {
 304         AliWarning(Form("Can not find class description for entry %s (%s)\n",
 305                         its->ClassName(), name.Data()));
 306         continue;
 307       }
 308
 309       mine=(TObject*)pClass->New();
 310       if(!mine){
 311       // not in this: can be added to list
 312         AliWarning(Form("%s:%d Could not find %s for copying \n",
 313                         (char*)__FILE__,__LINE__,name.Data()));
 314         continue;
 315       }
 316       if(mine->InheritsFrom("TNamed")){
 317         ((TNamed*)mine)->SetName(name);
 318       }
 319       else if(mine->InheritsFrom("TCollection")){
 320         if(mine->InheritsFrom("TClonesArray")) {
 321           TClonesArray* tcits = dynamic_cast<TClonesArray*>(its);
 322           if (tcits)
 323             dynamic_cast<TClonesArray*>(mine)->SetClass(tcits->GetClass());
 324         }
 325         dynamic_cast<TCollection*>(mine)->SetName(name);
 326       }
 327       AliDebug(1, Form("adding object %s of type %s", mine->GetName(), mine->ClassName()));
 328       AddObject(mine);
 329     }
 330
 331     if(!its->InheritsFrom("TCollection")){
 332       // simple objects
 333       its->Copy(*mine);
 334     }
 335     else if(its->InheritsFrom("TClonesArray")){
 336       // Create or expand the tclonesarray pointers
 337       // so we can directly copy to the object
 338       TClonesArray *itstca = (TClonesArray*)its;
 339       TClonesArray *minetca = (TClonesArray*)mine;
 340
 341       // this leaves the capacity of the TClonesArray the same
 342       // except for a factor of 2 increase when size > capacity
 343       // does not release any memory occupied by the tca
 344       minetca->ExpandCreate(itstca->GetEntriesFast());
 345       for(int i = 0;i < itstca->GetEntriesFast();++i){
 346         // copy
 347         TObject *minetcaobj = minetca->At(i);
 348         TObject *itstcaobj = itstca->At(i);
 349         // no need to delete first
 350         // pointers within the class should be handled by Copy()...
 351         // Can there be Empty slots?
 352         itstcaobj->Copy(*minetcaobj);
 353       }
 354     }
 355     else{
 356       AliWarning(Form("%s:%d cannot copy TCollection \n",
 357                       (char*)__FILE__,__LINE__));
 358     }
 359   }
 360
 361   fOldMuonStructure = source.fOldMuonStructure;
 362
 363   fCentrality = source.fCentrality;
 364   fEventplane = source.fEventplane;
 365
 366   fConnected  = source.fConnected;
 367   fUseOwnList = source.fUseOwnList;
 368
 369   fDetectorStatus = source.fDetectorStatus;
 370   fDAQDetectorPattern = source.fDAQDetectorPattern;
 371   fDAQAttributes = source.fDAQAttributes;
 372
 373   fTracksConnected = kFALSE;
 374   ConnectTracks();
 375   return *this;
 376 }
 377
 378
 379 //______________________________________________________________________________
 380 AliESDEvent::~AliESDEvent()
 381 {
 382   //
 383   // Standard destructor
 384   //
 385
 386   // everthing on the list gets deleted automatically
 387
 388
 389   if(fESDObjects&&!fConnected)
 390     {
 391       delete fESDObjects;
 392       fESDObjects = 0;
 393     }
 394   if (fCentrality) delete fCentrality;
 395   if (fEventplane) delete fEventplane;
 396
 397
 398 }
 399
 400 void AliESDEvent::Copy(TObject &obj) const {
 401
 402   // interface to TOBject::Copy
 403   // Copies the content of this into obj!
 404   // bascially obj = *this
 405
 406   if(this==&obj)return;
 407   AliESDEvent *robj = dynamic_cast<AliESDEvent*>(&obj);
 408   if(!robj)return; // not an AliESEvent
 409   *robj = *this;
 410   return;
 411 }
 412
 413 //______________________________________________________________________________
 414 void AliESDEvent::Reset()
 415 {
 416
 417   // Handle the cases
 418   // Std content + Non std content
 419
 420   // Reset the standard contents
 421   ResetStdContent();
 422   fDetectorStatus = 0xFFFFFFFF;
 423   fDAQDetectorPattern = 0xFFFF;
 424   fDAQAttributes = 0xFFFF;
 425   //  reset for the old data without AliESDEvent...
 426   if(fESDOld)fESDOld->Reset();
 427   if(fESDFriendOld){
 428     fESDFriendOld->~AliESDfriend();
 429     new (fESDFriendOld) AliESDfriend();
 430   }
 431   //
 432
 433   if(fESDObjects->GetSize()>kESDListN){
 434     // we have non std content
 435     // this also covers esdfriends
 436     for(int i = kESDListN;i < fESDObjects->GetSize();++i){
 437       TObject *pObject = fESDObjects->At(i);
 438       // TClonesArrays
 439       if(pObject->InheritsFrom(TClonesArray::Class())){
 440         ((TClonesArray*)pObject)->Delete();
 441       }
 442       else if(!pObject->InheritsFrom(TCollection::Class())){
 443         TClass *pClass = TClass::GetClass(pObject->ClassName());
 444         if (pClass && pClass->GetListOfMethods()->FindObject("Clear")) {
 445           AliDebug(1, Form("Clear for object %s class %s", pObject->GetName(), pObject->ClassName()));
 446           pObject->Clear();
 447         }
 448         else {
 449           AliDebug(1, Form("ResetWithPlacementNew for object %s class %s", pObject->GetName(), pObject->ClassName()));
 450           ResetWithPlacementNew(pObject);
 451         }
 452       }
 453       else{
 454         AliWarning(Form("No reset for %s \n",
 455                         pObject->ClassName()));
 456       }
 457     }
 458   }
 459
 460 }
 461
 462 //______________________________________________________________________________
 463 Bool_t AliESDEvent::ResetWithPlacementNew(TObject *pObject){
 464   //
 465   // funtion to reset using the already allocated space
 466   //
 467   Long_t dtoronly = TObject::GetDtorOnly();
 468   TClass *pClass = TClass::GetClass(pObject->ClassName());
 469   TObject::SetDtorOnly(pObject);
 470   delete pObject;
 471   // Recreate with placement new
 472   pClass->New(pObject);
 473   // Restore the state.
 474   TObject::SetDtorOnly((void*)dtoronly);
 475   return kTRUE;
 476 }
 477
 478 //______________________________________________________________________________
 479 void AliESDEvent::ResetStdContent()
 480 {
 481   // Reset the standard contents
 482   if(fESDRun) fESDRun->Reset();
 483   if(fHeader) fHeader->Reset();
 484   if(fCentrality) fCentrality->Reset();
 485   if(fEventplane) fEventplane->Reset();
 486   if(fESDZDC) fESDZDC->Reset();
 487   if(fESDFMD) {
 488     fESDFMD->Clear();
 489   }
 490   if(fESDVZERO){
 491     // reset by callin d'to /c'tor keep the pointer
 492     fESDVZERO->~AliESDVZERO();
 493     new (fESDVZERO) AliESDVZERO();
 494   }
 495   if(fESDACORDE){
 496     fESDACORDE->~AliESDACORDE();
 497     new (fESDACORDE) AliESDACORDE();
 498   }
 499
 500   if(fESDAD){
 501     fESDAD->~AliESDAD();
 502     new (fESDAD) AliESDAD();
 503   }
 504
 505
 506   if(fESDTZERO) fESDTZERO->Reset();
 507   // CKB no clear/reset implemented
 508   if(fTPCVertex){
 509     fTPCVertex->~AliESDVertex();
 510     new (fTPCVertex) AliESDVertex();
 511     fTPCVertex->SetName(fgkESDListName[kTPCVertex]);
 512   }
 513   if(fSPDVertex){
 514     fSPDVertex->~AliESDVertex();
 515     new (fSPDVertex) AliESDVertex();
 516     fSPDVertex->SetName(fgkESDListName[kSPDVertex]);
 517   }
 518   if(fPrimaryVertex){
 519     fPrimaryVertex->~AliESDVertex();
 520     new (fPrimaryVertex) AliESDVertex();
 521     fPrimaryVertex->SetName(fgkESDListName[kPrimaryVertex]);
 522   }
 523   if(fSPDMult){
 524     fSPDMult->~AliMultiplicity();
 525     new (fSPDMult) AliMultiplicity();
 526   }
 527   if(fTOFHeader){
 528     fTOFHeader->~AliTOFHeader();
 529     new (fTOFHeader) AliTOFHeader();
 530     //fTOFHeader->SetName(fgkESDListName[kTOFHeader]);
 531   }
 532   if (fTrdTrigger) {
 533     fTrdTrigger->~AliESDTrdTrigger();
 534     new (fTrdTrigger) AliESDTrdTrigger();
 535   }
 536
 537   if(fPHOSTrigger)fPHOSTrigger->DeAllocate();
 538   if(fEMCALTrigger)fEMCALTrigger->DeAllocate();
 539   if(fSPDPileupVertices)fSPDPileupVertices->Delete();
 540   if(fTrkPileupVertices)fTrkPileupVertices->Delete();
 541   fTracksConnected = kFALSE;
 542   if(fTracks)fTracks->Delete();
 543   if(fMuonTracks)fMuonTracks->Clear("C");
 544   if(fMuonClusters)fMuonClusters->Clear("C");
 545   if(fMuonPads)fMuonPads->Clear("C");
 546   if(fMuonGlobalTracks)fMuonGlobalTracks->Clear("C");     // AU
 547   if(fPmdTracks)fPmdTracks->Delete();
 548   if(fTrdTracks)fTrdTracks->Delete();
 549   if(fTrdTracklets)fTrdTracklets->Delete();
 550   if(fV0s)fV0s->Delete();
 551   if(fCascades)fCascades->Delete();
 552   if(fKinks)fKinks->Delete();
 553   if(fCaloClusters)fCaloClusters->Delete();
 554   if(fPHOSCells)fPHOSCells->DeleteContainer();
 555   if(fEMCALCells)fEMCALCells->DeleteContainer();
 556   if(fCosmicTracks)fCosmicTracks->Delete();
 557   if(fESDTOFClusters)fESDTOFClusters->Clear();
 558   if(fESDTOFHits)fESDTOFHits->Clear();
 559   if(fESDTOFMatches)fESDTOFMatches->Clear();
 560   if(fErrorLogs) fErrorLogs->Delete();
 561
 562   // don't reset fconnected fConnected and the list
 563
 564 }
 565
 566
 567 //______________________________________________________________________________
 568 Int_t AliESDEvent::AddV0(const AliESDv0 *v) {
 569   //
 570   // Add V0
 571   //
 572   TClonesArray &fv = *fV0s;
 573   Int_t idx=fV0s->GetEntriesFast();
 574   new(fv[idx]) AliESDv0(*v);
 575   return idx;
 576 }
 577
 578 //______________________________________________________________________________
 579 Bool_t AliESDEvent::IsDetectorInTriggerCluster(TString detector, AliTriggerConfiguration* trigConf) const {
 580   // Check if a given detector was read-out in the analyzed event
 581   const TObjArray& classesArray=trigConf->GetClasses();
 582   ULong64_t trigMask=GetTriggerMask();
 583   ULong64_t trigMaskNext50=GetTriggerMaskNext50();
 584   Int_t nclasses = classesArray.GetEntriesFast();
 585   for(Int_t iclass=0; iclass < nclasses; iclass++ ) {
 586     AliTriggerClass* trclass = (AliTriggerClass*)classesArray.At(iclass);
 587     ULong64_t classMask=trclass->GetMask();
 588     ULong64_t classMaskNext50=trclass->GetMaskNext50();
 589     if(trigMask & classMask){
 590       TString detList=trclass->GetCluster()->GetDetectorsInCluster();
 591       if(detList.Contains(detector.Data())){
 592         return kTRUE;
 593       }
 594     }
 595     if(trigMaskNext50 & classMaskNext50){
 596       TString detList=trclass->GetCluster()->GetDetectorsInCluster();
 597       if(detList.Contains(detector.Data())){
 598         return kTRUE;
 599       }
 600     }
 601   }
 602   return kFALSE;
 603 }
 604 //______________________________________________________________________________
 605 void AliESDEvent::Print(Option_t *) const
 606 {
 607   //
 608   // Print header information of the event
 609   //
 610   printf("ESD run information\n");
 611   printf("Event # in file %d Bunch crossing # %d Orbit # %d Period # %d Run # %d Trigger %lld %lld Magnetic field %f \n",
 612          GetEventNumberInFile(),
 613          GetBunchCrossNumber(),
 614          GetOrbitNumber(),
 615          GetPeriodNumber(),
 616          GetRunNumber(),
 617          GetTriggerMask(),
 618          GetTriggerMaskNext50(),
 619          GetMagneticField() );
 620   if (fPrimaryVertex)
 621     printf("Vertex: (%.4f +- %.4f, %.4f +- %.4f, %.4f +- %.4f) cm\n",
 622            fPrimaryVertex->GetX(), fPrimaryVertex->GetXRes(),
 623            fPrimaryVertex->GetY(), fPrimaryVertex->GetYRes(),
 624            fPrimaryVertex->GetZ(), fPrimaryVertex->GetZRes());
 625   printf("Mean vertex in RUN: X=%.4f Y=%.4f Z=%.4f cm\n",
 626          GetDiamondX(),GetDiamondY(),GetDiamondZ());
 627   if(fSPDMult)
 628     printf("SPD Multiplicity. Number of tracklets %d \n",
 629            fSPDMult->GetNumberOfTracklets());
 630   printf("Number of pileup primary vertices reconstructed with SPD %d\n",
 631          GetNumberOfPileupVerticesSPD());
 632   printf("Number of pileup primary vertices reconstructed using the tracks %d\n",
 633          GetNumberOfPileupVerticesTracks());
 634   printf("Number of tracks: \n");
 635   printf("                 charged   %d\n", GetNumberOfTracks());
 636   printf("                 muon      %d\n", GetNumberOfMuonTracks());
 637   printf("                 glob muon %d\n", GetNumberOfMuonGlobalTracks());    // AU
 638   printf("                 pmd       %d\n", GetNumberOfPmdTracks());
 639   printf("                 trd       %d\n", GetNumberOfTrdTracks());
 640   printf("                 trd trkl  %d\n", GetNumberOfTrdTracklets());
 641   printf("                 v0        %d\n", GetNumberOfV0s());
 642   printf("                 cascades  %d\n", GetNumberOfCascades());
 643   printf("                 kinks     %d\n", GetNumberOfKinks());
 644   if(fPHOSCells)printf("                 PHOSCells %d\n", fPHOSCells->GetNumberOfCells());
 645   else printf("                 PHOSCells not in the Event\n");
 646   if(fEMCALCells)printf("                 EMCALCells %d\n", fEMCALCells->GetNumberOfCells());
 647   else printf("                 EMCALCells not in the Event\n");
 648   printf("                 CaloClusters %d\n", GetNumberOfCaloClusters());
 649   printf("                 FMD       %s\n", (fESDFMD ? "yes" : "no"));
 650   printf("                 VZERO     %s\n", (fESDVZERO ? "yes" : "no"));
 651   printf("                 muClusters %d\n", fMuonClusters ? fMuonClusters->GetEntriesFast() : 0);
 652   printf("                 muPad     %d\n", fMuonPads ? fMuonPads->GetEntriesFast() : 0);
 653   if (fCosmicTracks) printf("                 Cosmics   %d\n",  GetNumberOfCosmicTracks());
 654
 655   TObject* pHLTDecision=GetHLTTriggerDecision();
 656   printf("HLT trigger decision: %s\n", pHLTDecision?pHLTDecision->GetOption():"not available");
 657   if (pHLTDecision) pHLTDecision->Print("compact");
 658
 659   return;
 660 }
 661
 662 //______________________________________________________________________________
 663 void AliESDEvent::SetESDfriend(const AliESDfriend *ev) const
 664 {
 665 //
 666 // Attaches the complementary info to the ESD
 667 //
 668   if (!ev) return;
 669
 670   // to be sure that we set the tracks also
 671   // in case of old esds
 672   // if(fESDOld)CopyFromOldESD();
 673
 674   Int_t ntrk=ev->GetNumberOfTracks();
 675
 676   for (Int_t i=0; i<ntrk; i++) {
 677     const AliESDfriendTrack *f=ev->GetTrack(i);
 678     if (!f) {AliFatal(Form("NULL pointer for ESD track %d",i));}
 679     GetTrack(i)->SetFriendTrack(f);
 680   }
 681 }
 682
 683 //______________________________________________________________________________
 684 Bool_t  AliESDEvent::RemoveKink(Int_t rm) const
 685 {
 686 // ---------------------------------------------------------
 687 // Remove a kink candidate and references to it from ESD,
 688 // if this candidate does not come from a reconstructed decay
 689 // Not yet implemented...
 690 // ---------------------------------------------------------
 691   Int_t last=GetNumberOfKinks()-1;
 692   if ((rm<0)||(rm>last)) return kFALSE;
 693
 694   return kTRUE;
 695 }
 696
 697 //______________________________________________________________________________
 698 Bool_t  AliESDEvent::RemoveV0(Int_t rm) const
 699 {
 700 // ---------------------------------------------------------
 701 // Remove a V0 candidate and references to it from ESD,
 702 // if this candidate does not come from a reconstructed decay
 703 // ---------------------------------------------------------
 704   Int_t last=GetNumberOfV0s()-1;
 705   if ((rm<0)||(rm>last)) return kFALSE;
 706
 707   AliESDv0 *v0=GetV0(rm);
 708   Int_t idxP=v0->GetPindex(), idxN=v0->GetNindex();
 709
 710   v0=GetV0(last);
 711   Int_t lastIdxP=v0->GetPindex(), lastIdxN=v0->GetNindex();
 712
 713   Int_t used=0;
 714
 715   // Check if this V0 comes from a reconstructed decay
 716   Int_t ncs=GetNumberOfCascades();
 717   for (Int_t n=0; n<ncs; n++) {
 718     AliESDcascade *cs=GetCascade(n);
 719
 720     Int_t csIdxP=cs->GetPindex();
 721     Int_t csIdxN=cs->GetNindex();
 722
 723     if (idxP==csIdxP)
 724        if (idxN==csIdxN) return kFALSE;
 725
 726     if (csIdxP==lastIdxP)
 727        if (csIdxN==lastIdxN) used++;
 728   }
 729
 730   //Replace the removed V0 with the last V0
 731   TClonesArray &a=*fV0s;
 732   delete a.RemoveAt(rm);
 733
 734   if (rm==last) return kTRUE;
 735
 736   //v0 is pointing to the last V0 candidate...
 737   new (a[rm]) AliESDv0(*v0);
 738   delete a.RemoveAt(last);
 739
 740   if (!used) return kTRUE;
 741
 742
 743   // Remap the indices of the daughters of reconstructed decays
 744   for (Int_t n=0; n<ncs; n++) {
 745     AliESDcascade *cs=GetCascade(n);
 746
 747
 748     Int_t csIdxP=cs->GetPindex();
 749     Int_t csIdxN=cs->GetNindex();
 750
 751     if (csIdxP==lastIdxP)
 752       if (csIdxN==lastIdxN) {
 753          cs->AliESDv0::SetIndex(1,idxP);
 754          cs->AliESDv0::SetIndex(0,idxN);
 755          used--;
 756          if (!used) return kTRUE;
 757       }
 758   }
 759
 760   return kTRUE;
 761 }
 762
 763 //______________________________________________________________________________
 764 Bool_t  AliESDEvent::RemoveTrack(Int_t rm) const
 765 {
 766 // ---------------------------------------------------------
 767 // Remove a track and references to it from ESD,
 768 // if this track does not come from a reconstructed decay
 769 // ---------------------------------------------------------
 770   Int_t last=GetNumberOfTracks()-1;
 771   if ((rm<0)||(rm>last)) return kFALSE;
 772
 773   Int_t used=0;
 774
 775   // Check if this track comes from the reconstructed primary vertices
 776   if (fTPCVertex && fTPCVertex->GetStatus()) {
 777      UShort_t *primIdx=fTPCVertex->GetIndices();
 778      Int_t n=fTPCVertex->GetNIndices();
 779      while (n--) {
 780        Int_t idx=Int_t(primIdx[n]);
 781        if (rm==idx) return kFALSE;
 782        if (idx==last) used++;
 783      }
 784   }
 785   if (fPrimaryVertex && fPrimaryVertex->GetStatus()) {
 786      UShort_t *primIdx=fPrimaryVertex->GetIndices();
 787      Int_t n=fPrimaryVertex->GetNIndices();
 788      while (n--) {
 789        Int_t idx=Int_t(primIdx[n]);
 790        if (rm==idx) return kFALSE;
 791        if (idx==last) used++;
 792      }
 793   }
 794
 795   // Check if this track comes from a reconstructed decay
 796   Int_t nv0=GetNumberOfV0s();
 797   for (Int_t n=0; n<nv0; n++) {
 798     AliESDv0 *v0=GetV0(n);
 799
 800     Int_t idx=v0->GetNindex();
 801     if (rm==idx) return kFALSE;
 802     if (idx==last) used++;
 803
 804     idx=v0->GetPindex();
 805     if (rm==idx) return kFALSE;
 806     if (idx==last) used++;
 807   }
 808
 809   Int_t ncs=GetNumberOfCascades();
 810   for (Int_t n=0; n<ncs; n++) {
 811     AliESDcascade *cs=GetCascade(n);
 812
 813     Int_t idx=cs->GetIndex();
 814     if (rm==idx) return kFALSE;
 815     if (idx==last) used++;
 816
 817     AliESDv0 *v0=cs;
 818     idx=v0->GetNindex();
 819     if (rm==idx) return kFALSE;
 820     if (idx==last) used++;
 821
 822     idx=v0->GetPindex();
 823     if (rm==idx) return kFALSE;
 824     if (idx==last) used++;
 825   }
 826
 827   Int_t nkn=GetNumberOfKinks();
 828   for (Int_t n=0; n<nkn; n++) {
 829     AliESDkink *kn=GetKink(n);
 830
 831     Int_t idx=kn->GetIndex(0);
 832     if (rm==idx) return kFALSE;
 833     if (idx==last) used++;
 834
 835     idx=kn->GetIndex(1);
 836     if (rm==idx) return kFALSE;
 837     if (idx==last) used++;
 838   }
 839
 840   // Check if this track is associated with a CaloCluster
 841   Int_t ncl=GetNumberOfCaloClusters();
 842   for (Int_t n=0; n<ncl; n++) {
 843     AliESDCaloCluster *cluster=GetCaloCluster(n);
 844     TArrayI *arr=cluster->GetTracksMatched();
 845     Int_t s=arr->GetSize();
 846     while (s--) {
 847       Int_t idx=arr->At(s);
 848       if (rm==idx) return kFALSE;
 849       if (idx==last) used++;
 850     }
 851   }
 852
 853   // from here on we remove the track
 854   //
 855   //Replace the removed track with the last track
 856   TClonesArray &a=*fTracks;
 857   AliESDtrack* trm = GetTrack(rm);
 858   trm->SuppressTOFMatches(); // remove reference to this track from stored TOF clusters
 859   delete a.RemoveAt(rm);
 860   //
 861   if (rm==last) return kTRUE;
 862
 863   AliESDtrack *t=GetTrack(last);
 864   if (!t) {AliFatal(Form("NULL pointer for ESD track %d",last));}
 865   t->SetID(rm);
 866   new (a[rm]) AliESDtrack(*t);
 867   delete a.RemoveAt(last);
 868
 869   if (!used) return kTRUE;
 870
 871
 872   // Remap the indices of the tracks used for the primary vertex reconstruction
 873   if (fTPCVertex && fTPCVertex->GetStatus()) {
 874      UShort_t *primIdx=fTPCVertex->GetIndices();
 875      Int_t n=fTPCVertex->GetNIndices();
 876      while (n--) {
 877        Int_t idx=Int_t(primIdx[n]);
 878        if (idx==last) {
 879           primIdx[n]=Short_t(rm);
 880           used--;
 881           if (!used) return kTRUE;
 882        }
 883      }
 884   }
 885   if (fPrimaryVertex && fPrimaryVertex->GetStatus()) {
 886      UShort_t *primIdx=fPrimaryVertex->GetIndices();
 887      Int_t n=fPrimaryVertex->GetNIndices();
 888      while (n--) {
 889        Int_t idx=Int_t(primIdx[n]);
 890        if (idx==last) {
 891           primIdx[n]=Short_t(rm);
 892           used--;
 893           if (!used) return kTRUE;
 894        }
 895      }
 896   }
 897
 898   // Remap the indices of the daughters of reconstructed decays
 899   for (Int_t n=0; n<nv0; n++) {
 900     AliESDv0 *v0=GetV0(n);
 901     if (v0->GetIndex(0)==last) {
 902        v0->SetIndex(0,rm);
 903        used--;
 904        if (!used) return kTRUE;
 905     }
 906     if (v0->GetIndex(1)==last) {
 907        v0->SetIndex(1,rm);
 908        used--;
 909        if (!used) return kTRUE;
 910     }
 911   }
 912
 913   for (Int_t n=0; n<ncs; n++) {
 914     AliESDcascade *cs=GetCascade(n);
 915     if (cs->GetIndex()==last) {
 916        cs->SetIndex(rm);
 917        used--;
 918        if (!used) return kTRUE;
 919     }
 920     AliESDv0 *v0=cs;
 921     if (v0->GetIndex(0)==last) {
 922        v0->SetIndex(0,rm);
 923        used--;
 924        if (!used) return kTRUE;
 925     }
 926     if (v0->GetIndex(1)==last) {
 927        v0->SetIndex(1,rm);
 928        used--;
 929        if (!used) return kTRUE;
 930     }
 931   }
 932
 933   for (Int_t n=0; n<nkn; n++) {
 934     AliESDkink *kn=GetKink(n);
 935     if (kn->GetIndex(0)==last) {
 936        kn->SetIndex(rm,0);
 937        used--;
 938        if (!used) return kTRUE;
 939     }
 940     if (kn->GetIndex(1)==last) {
 941        kn->SetIndex(rm,1);
 942        used--;
 943        if (!used) return kTRUE;
 944     }
 945   }
 946
 947   // Remap the indices of the tracks accosicated with CaloClusters
 948   for (Int_t n=0; n<ncl; n++) {
 949     AliESDCaloCluster *cluster=GetCaloCluster(n);
 950     TArrayI *arr=cluster->GetTracksMatched();
 951     Int_t s=arr->GetSize();
 952     while (s--) {
 953       Int_t idx=arr->At(s);
 954       if (idx==last) {
 955          arr->AddAt(rm,s);
 956          used--;
 957          if (!used) return kTRUE;
 958       }
 959     }
 960   }
 961
 962   return kTRUE;
 963 }
 964
 965 //______________________________________________________________________________
 966 Bool_t AliESDEvent::Clean(Float_t *cleanPars)
 967 {
 968   //
 969   // Remove the data which are not needed for the physics analysis.
 970   //
 971   // 1) Cleaning the V0 candidates
 972   //    ---------------------------
 973   //    If the cosine of the V0 pointing angle "csp" and
 974   //    the DCA between the daughter tracks "dca" does not satisfy
 975   //    the conditions
 976   //
 977   //     csp > cleanPars[1] + dca/cleanPars[0]*(1.- cleanPars[1])
 978   //
 979   //    an attempt to remove this V0 candidate from ESD is made.
 980   //
 981   //    The V0 candidate gets removed if it does not belong to any
 982   //    recosntructed cascade decay
 983   //
 984   //    12.11.2007, optimal values: cleanPars[0]=0.5, cleanPars[1]=0.999
 985   //
 986   // 2) Cleaning the tracks
 987   //    ----------------------
 988   //    If track's transverse parameter is larger than cleanPars[2]
 989   //                       OR
 990   //    track's longitudinal parameter is larger than cleanPars[3]
 991   //    an attempt to remove this track from ESD is made.
 992   //
 993   //    The track gets removed if it does not come
 994   //    from a reconstructed decay
 995   //
 996   Bool_t rc=kFALSE;
 997
 998   Float_t dcaMax=cleanPars[0];
 999   Float_t cspMin=cleanPars[1];
1000
1001   Int_t nV0s=GetNumberOfV0s();
1002   for (Int_t i=nV0s-1; i>=0; i--) {
1003     AliESDv0 *v0=GetV0(i);
1004
1005     Float_t dca=v0->GetDcaV0Daughters();
1006     Float_t csp=v0->GetV0CosineOfPointingAngle();
1007     Float_t cspcut=cspMin + dca/dcaMax*(1.-cspMin);
1008     if (csp > cspcut) continue;
1009     if (RemoveV0(i)) rc=kTRUE;
1010   }
1011
1012
1013   Float_t dmax=cleanPars[2], zmax=cleanPars[3];
1014
1015   const AliESDVertex *vertex=GetPrimaryVertexSPD();
1016   Bool_t vtxOK=vertex->GetStatus();
1017
1018   Int_t nTracks=GetNumberOfTracks();
1019   for (Int_t i=nTracks-1; i>=0; i--) {
1020     AliESDtrack *track=GetTrack(i);
1021     if (!track) {AliFatal(Form("NULL pointer for ESD track %d",i));}
1022     Float_t xy,z; track->GetImpactParameters(xy,z);
1023     if ((TMath::Abs(xy) > dmax) || (vtxOK && (TMath::Abs(z) > zmax))) {
1024       if (RemoveTrack(i)) rc=kTRUE;
1025     }
1026   }
1027
1028   return rc;
1029 }
1030
1031 //______________________________________________________________________________
1032 Char_t  AliESDEvent::AddPileupVertexSPD(const AliESDVertex *vtx)
1033 {
1034     // Add a pileup primary vertex reconstructed with SPD
1035     TClonesArray &ftr = *fSPDPileupVertices;
1036     Char_t n=Char_t(ftr.GetEntriesFast());
1037     AliESDVertex *vertex = new(ftr[n]) AliESDVertex(*vtx);
1038     vertex->SetID(n);
1039     return n;
1040 }
1041
1042 //______________________________________________________________________________
1043 Char_t  AliESDEvent::AddPileupVertexTracks(const AliESDVertex *vtx)
1044 {
1045     // Add a pileup primary vertex reconstructed with SPD
1046     TClonesArray &ftr = *fTrkPileupVertices;
1047     Char_t n=Char_t(ftr.GetEntriesFast());
1048     AliESDVertex *vertex = new(ftr[n]) AliESDVertex(*vtx);
1049     vertex->SetID(n);
1050     return n;
1051 }
1052
1053 //______________________________________________________________________________
1054 Int_t  AliESDEvent::AddTrack(const AliESDtrack *t)
1055 {
1056     // Add track
1057     TClonesArray &ftr = *fTracks;
1058     AliESDtrack * track = new(ftr[fTracks->GetEntriesFast()])AliESDtrack(*t);
1059     track->SetID(fTracks->GetEntriesFast()-1);
1060     track->SetESDEvent(this);
1061     return  track->GetID();
1062 }
1063
1064 //______________________________________________________________________________
1065 AliESDtrack*  AliESDEvent::NewTrack()
1066 {
1067     // Add a new track
1068     TClonesArray &ftr = *fTracks;
1069     AliESDtrack * track = new(ftr[fTracks->GetEntriesFast()])AliESDtrack();
1070     track->SetID(fTracks->GetEntriesFast()-1);
1071     track->SetESDEvent(this);
1072     return  track;
1073 }
1074
1075 //______________________________________________________________________________
1076 Bool_t AliESDEvent::MoveMuonObjects()
1077 {
1078   // move MUON clusters and pads to the new ESD structure in needed.
1079   // to ensure backward compatibility
1080
1081   if (!fOldMuonStructure) return kTRUE;
1082
1083   if (!fMuonTracks || !fMuonClusters || !fMuonPads) return kFALSE;
1084
1085   Bool_t reset = kTRUE;
1086   Bool_t containTrackerData = kFALSE;
1087   for (Int_t i = 0; i < fMuonTracks->GetEntriesFast(); i++) {
1088
1089     AliESDMuonTrack *track = (AliESDMuonTrack*) fMuonTracks->UncheckedAt(i);
1090
1091     if (track->ContainTrackerData()) containTrackerData = kTRUE;
1092     else continue;
1093
1094     if (!track->IsOldTrack()) continue;
1095
1096     // remove objects connected to previous event if needed
1097     if (reset) {
1098       if (fMuonClusters->GetEntriesFast() > 0) fMuonClusters->Clear("C");
1099       if (fMuonPads->GetEntriesFast() > 0) fMuonPads->Clear("C");
1100       reset = kFALSE;
1101     }
1102
1103     track->MoveClustersToESD(*this);
1104
1105   }
1106
1107   // remove objects connected to previous event if needed
1108   if (!containTrackerData) {
1109     if (fMuonClusters->GetEntriesFast() > 0) fMuonClusters->Clear("C");
1110     if (fMuonPads->GetEntriesFast() > 0) fMuonPads->Clear("C");
1111   }
1112
1113   return kTRUE;
1114 }
1115
1116 //______________________________________________________________________________
1117 AliESDMuonTrack* AliESDEvent::GetMuonTrack(Int_t i)
1118 {
1119   // get the MUON track at the position i in the internal array of track
1120   if (!fMuonTracks) return 0x0;
1121   if (!MoveMuonObjects()) return 0x0;
1122   AliESDMuonTrack *track = (AliESDMuonTrack*) fMuonTracks->UncheckedAt(i);
1123   track->SetESDEvent(this);
1124   return track;
1125 }
1126
1127 //______________________________________________________________________________
1128 AliESDMuonGlobalTrack* AliESDEvent::GetMuonGlobalTrack(Int_t i)                      // AU
1129 {
1130   // get the MUON+MFT track at the position i in the internal array of track
1131   if (!fMuonGlobalTracks) return 0x0;
1132   AliESDMuonGlobalTrack *track = (AliESDMuonGlobalTrack*) fMuonGlobalTracks->UncheckedAt(i);
1133   track->SetESDEvent(this);
1134   return track;
1135 }
1136
1137 //______________________________________________________________________________
1138 void AliESDEvent::AddMuonTrack(const AliESDMuonTrack *t)
1139 {
1140   // add a MUON track
1141   TClonesArray &fmu = *fMuonTracks;
1142   AliESDMuonTrack *track = new(fmu[fMuonTracks->GetEntriesFast()]) AliESDMuonTrack(*t);
1143   track->MoveClustersToESD(*this);
1144 }
1145
1146 //______________________________________________________________________________
1147 void AliESDEvent::AddMuonGlobalTrack(const AliESDMuonGlobalTrack *t)                             // AU
1148 {
1149   // add a MUON+MFT track
1150   TClonesArray &fmu = *fMuonGlobalTracks;
1151   new (fmu[fMuonGlobalTracks->GetEntriesFast()]) AliESDMuonGlobalTrack(*t);
1152 }
1153
1154 //______________________________________________________________________________
1155
1156 AliESDMuonTrack* AliESDEvent::NewMuonTrack()
1157 {
1158   // create a new MUON track at the end of the internal array of track
1159   TClonesArray &fmu = *fMuonTracks;
1160   return new(fmu[fMuonTracks->GetEntriesFast()]) AliESDMuonTrack();
1161 }
1162
1163 //______________________________________________________________________________
1164 AliESDMuonGlobalTrack* AliESDEvent::NewMuonGlobalTrack()                                         // AU
1165 {
1166   // create a new MUON+MFT track at the end of the internal array of track
1167   TClonesArray &fmu = *fMuonGlobalTracks;
1168   return new(fmu[fMuonGlobalTracks->GetEntriesFast()]) AliESDMuonGlobalTrack();
1169 }
1170
1171 //______________________________________________________________________________
1172 Int_t AliESDEvent::GetNumberOfMuonClusters()
1173 {
1174   // get the number of MUON clusters
1175   if (!fMuonClusters) return 0;
1176   if (!MoveMuonObjects()) return 0;
1177   return fMuonClusters->GetEntriesFast();
1178 }
1179
1180 //______________________________________________________________________________
1181 AliESDMuonCluster* AliESDEvent::GetMuonCluster(Int_t i)
1182 {
1183   // get the MUON cluster at the position i in the internal array of cluster
1184   if (!fMuonClusters) return 0x0;
1185   if (!MoveMuonObjects()) return 0x0;
1186   return (AliESDMuonCluster*) fMuonClusters->UncheckedAt(i);
1187 }
1188
1189 //______________________________________________________________________________
1190 AliESDMuonCluster* AliESDEvent::FindMuonCluster(UInt_t clusterId)
1191 {
1192   // find the MUON cluster with this Id in the internal array of cluster
1193   if (!fMuonClusters) return 0x0;
1194   if (!MoveMuonObjects()) return 0x0;
1195   for (Int_t i = 0; i < fMuonClusters->GetEntriesFast(); i++) {
1196     AliESDMuonCluster *cluster = (AliESDMuonCluster*) fMuonClusters->UncheckedAt(i);
1197     if (cluster->GetUniqueID() == clusterId) return cluster;
1198   }
1199   return 0x0;
1200 }
1201
1202 //______________________________________________________________________________
1203 AliESDMuonCluster* AliESDEvent::NewMuonCluster()
1204 {
1205   // create a new MUON cluster at the end of the internal array of cluster
1206   TClonesArray &fmu = *fMuonClusters;
1207   return new(fmu[fMuonClusters->GetEntriesFast()]) AliESDMuonCluster();
1208 }
1209
1210 //______________________________________________________________________________
1211 Int_t AliESDEvent::GetNumberOfMuonPads()
1212 {
1213   // get the number of MUON pads
1214   if (!fMuonPads) return 0;
1215   if (!MoveMuonObjects()) return 0;
1216   return fMuonPads->GetEntriesFast();
1217 }
1218
1219 //______________________________________________________________________________
1220 AliESDMuonPad* AliESDEvent::GetMuonPad(Int_t i)
1221 {
1222   // get the MUON pad at the position i in the internal array of pad
1223   if (!fMuonPads) return 0x0;
1224   if (!MoveMuonObjects()) return 0x0;
1225   return (AliESDMuonPad*) fMuonPads->UncheckedAt(i);
1226 }
1227
1228 //______________________________________________________________________________
1229 AliESDMuonPad* AliESDEvent::FindMuonPad(UInt_t padId)
1230 {
1231   // find the MUON pad with this Id in the internal array of pad
1232   if (!fMuonPads) return 0x0;
1233   if (!MoveMuonObjects()) return 0x0;
1234   for (Int_t i = 0; i < fMuonPads->GetEntriesFast(); i++) {
1235     AliESDMuonPad *pad = (AliESDMuonPad*) fMuonPads->UncheckedAt(i);
1236     if (pad->GetUniqueID() == padId) return pad;
1237   }
1238   return 0x0;
1239 }
1240
1241 //______________________________________________________________________________
1242 AliESDMuonPad* AliESDEvent::NewMuonPad()
1243 {
1244   // create a new MUON pad at the end of the internal array of pad
1245   TClonesArray &fmu = *fMuonPads;
1246   return new(fmu[fMuonPads->GetEntriesFast()]) AliESDMuonPad();
1247 }
1248
1249 //______________________________________________________________________________
1250 void AliESDEvent::AddPmdTrack(const AliESDPmdTrack *t)
1251 {
1252   TClonesArray &fpmd = *fPmdTracks;
1253   new(fpmd[fPmdTracks->GetEntriesFast()]) AliESDPmdTrack(*t);
1254 }
1255
1256 //______________________________________________________________________________
1257 void AliESDEvent::SetTrdTrigger(const AliESDTrdTrigger *t)
1258 {
1259   *fTrdTrigger = *t;
1260 }
1261
1262 //______________________________________________________________________________
1263 void AliESDEvent::AddTrdTrack(const AliESDTrdTrack *t)
1264 {
1265   TClonesArray &ftrd = *fTrdTracks;
1266   new(ftrd[fTrdTracks->GetEntriesFast()]) AliESDTrdTrack(*t);
1267 }
1268
1269 //______________________________________________________________________________
1270 void AliESDEvent::AddTrdTracklet(const AliESDTrdTracklet *trkl)
1271 {
1272   new ((*fTrdTracklets)[fTrdTracklets->GetEntriesFast()]) AliESDTrdTracklet(*trkl);
1273 }
1274
1275 //______________________________________________________________________________
1276 void AliESDEvent::AddTrdTracklet(UInt_t trackletWord, Short_t hcid, Int_t label)
1277 {
1278   new ((*fTrdTracklets)[fTrdTracklets->GetEntriesFast()]) AliESDTrdTracklet(trackletWord, hcid, label);
1279 }
1280
1281 //______________________________________________________________________________
1282 Int_t AliESDEvent::AddKink(const AliESDkink *c)
1283 {
1284   // Add kink
1285   TClonesArray &fk = *fKinks;
1286   AliESDkink * kink = new(fk[fKinks->GetEntriesFast()]) AliESDkink(*c);
1287   kink->SetID(fKinks->GetEntriesFast()); // CKB different from the other imps..
1288   return fKinks->GetEntriesFast()-1;
1289 }
1290
1291
1292 //______________________________________________________________________________
1293 void AliESDEvent::AddCascade(const AliESDcascade *c)
1294 {
1295   TClonesArray &fc = *fCascades;
1296   new(fc[fCascades->GetEntriesFast()]) AliESDcascade(*c);
1297 }
1298
1299 //______________________________________________________________________________
1300 void AliESDEvent::AddCosmicTrack(const AliESDCosmicTrack *t)
1301 {
1302   TClonesArray &ft = *fCosmicTracks;
1303   new(ft[fCosmicTracks->GetEntriesFast()]) AliESDCosmicTrack(*t);
1304 }
1305
1306
1307 //______________________________________________________________________________
1308 Int_t AliESDEvent::AddCaloCluster(const AliESDCaloCluster *c)
1309 {
1310   // Add calocluster
1311   TClonesArray &fc = *fCaloClusters;
1312   AliESDCaloCluster *clus = new(fc[fCaloClusters->GetEntriesFast()]) AliESDCaloCluster(*c);
1313   clus->SetID(fCaloClusters->GetEntriesFast()-1);
1314   return fCaloClusters->GetEntriesFast()-1;
1315 }
1316
1317
1318 //______________________________________________________________________________
1319 void  AliESDEvent::AddRawDataErrorLog(const AliRawDataErrorLog *log) const {
1320   TClonesArray &errlogs = *fErrorLogs;
1321   new(errlogs[errlogs.GetEntriesFast()])  AliRawDataErrorLog(*log);
1322 }
1323
1324 //______________________________________________________________________________
1325 void AliESDEvent::SetZDCData(const AliESDZDC * obj)
1326 {
1327   // use already allocated space
1328   if(fESDZDC)
1329     *fESDZDC = *obj;
1330 }
1331
1332 //______________________________________________________________________________
1333 void  AliESDEvent::SetPrimaryVertexTPC(const AliESDVertex *vertex)
1334 {
1335   // Set the TPC vertex
1336   // use already allocated space
1337   if(fTPCVertex){
1338     *fTPCVertex = *vertex;
1339     fTPCVertex->SetName(fgkESDListName[kTPCVertex]);
1340   }
1341 }
1342
1343 //______________________________________________________________________________
1344 void  AliESDEvent::SetPrimaryVertexSPD(const AliESDVertex *vertex)
1345 {
1346   // Set the SPD vertex
1347   // use already allocated space
1348   if(fSPDVertex){
1349     *fSPDVertex = *vertex;
1350     fSPDVertex->SetName(fgkESDListName[kSPDVertex]);
1351   }
1352 }
1353
1354 //______________________________________________________________________________
1355 void  AliESDEvent::SetPrimaryVertexTracks(const AliESDVertex *vertex)
1356 {
1357   // Set the primary vertex reconstructed using he ESD tracks.
1358   // use already allocated space
1359   if(fPrimaryVertex){
1360     *fPrimaryVertex = *vertex;
1361     fPrimaryVertex->SetName(fgkESDListName[kPrimaryVertex]);
1362   }
1363 }
1364
1365 //______________________________________________________________________________
1366 const AliESDVertex * AliESDEvent::GetPrimaryVertex() const
1367 {
1368   //
1369   // Get the "best" available reconstructed primary vertex.
1370   //
1371   if(fPrimaryVertex){
1372     if (fPrimaryVertex->GetStatus()) return fPrimaryVertex;
1373   }
1374   if(fSPDVertex){
1375     if (fSPDVertex->GetStatus()) return fSPDVertex;
1376   }
1377   if(fTPCVertex) return fTPCVertex;
1378
1379   AliWarning("No primary vertex available. Returning the \"default\"...");
1380   return fSPDVertex;
1381 }
1382
1383 //______________________________________________________________________________
1384 AliESDVertex * AliESDEvent::PrimaryVertexTracksUnconstrained() const
1385 {
1386   //
1387   // Removes diamond constraint from fPrimaryVertex (reconstructed with tracks)
1388   // Returns a AliESDVertex which has to be deleted by the user
1389   //
1390   if(!fPrimaryVertex) {
1391     AliWarning("No primary vertex from tracks available.");
1392     return 0;
1393   }
1394   if(!fPrimaryVertex->GetStatus()) {
1395     AliWarning("No primary vertex from tracks available.");
1396     return 0;
1397   }
1398
1399   AliVertexerTracks vertexer(GetMagneticField());
1400   Float_t diamondxyz[3]={(Float_t)GetDiamondX(),(Float_t)GetDiamondY(),0.};
1401   Float_t diamondcovxy[3]; GetDiamondCovXY(diamondcovxy);
1402   Float_t diamondcov[6]={diamondcovxy[0],diamondcovxy[1],diamondcovxy[2],0.,0.,7.};
1403   AliESDVertex *vertex =
1404     (AliESDVertex*)vertexer.RemoveConstraintFromVertex(fPrimaryVertex,diamondxyz,diamondcov);
1405
1406   return vertex;
1407 }
1408
1409 //______________________________________________________________________________
1410 void AliESDEvent::SetMultiplicity(const AliMultiplicity *mul)
1411 {
1412   // Set the SPD Multiplicity
1413   if(fSPDMult){
1414     *fSPDMult = *mul;
1415   }
1416 }
1417
1418
1419 //______________________________________________________________________________
1420 void AliESDEvent::SetFMDData(AliESDFMD * obj)
1421 {
1422   // use already allocated space
1423   if(fESDFMD){
1424     *fESDFMD = *obj;
1425   }
1426 }
1427
1428 //______________________________________________________________________________
1429 void AliESDEvent::SetVZEROData(const AliESDVZERO * obj)
1430 {
1431   // use already allocated space
1432   if(fESDVZERO)
1433     *fESDVZERO = *obj;
1434 }
1435
1436 //______________________________________________________________________________
1437 void AliESDEvent::SetTZEROData(const AliESDTZERO * obj)
1438 {
1439   // use already allocated space
1440   if(fESDTZERO)
1441     *fESDTZERO = *obj;
1442 }
1443
1444
1445 //______________________________________________________________________________
1446 void AliESDEvent::SetACORDEData(AliESDACORDE * obj)
1447 {
1448   if(fESDACORDE)
1449     *fESDACORDE = *obj;
1450 }
1451
1452 //______________________________________________________________________________
1453 void AliESDEvent::SetADData(AliESDAD * obj)
1454 {
1455   if(fESDAD)
1456     *fESDAD = *obj;
1457 }
1458
1459 //______________________________________________________________________________
1460 void AliESDEvent::GetESDfriend(AliESDfriend *ev) const
1461 {
1462   //
1463   // Extracts the complementary info from the ESD
1464   //
1465   if (!ev) return;
1466
1467   Int_t ntrk=GetNumberOfTracks();
1468
1469   for (Int_t i=0; i<ntrk; i++) {
1470     AliESDtrack *t=GetTrack(i);
1471     if (!t) {AliFatal(Form("NULL pointer for ESD track %d",i));}
1472     const AliESDfriendTrack *f=t->GetFriendTrack();
1473     ev->AddTrack(f);
1474
1475     t->ReleaseESDfriendTrack();// Not to have two copies of "friendTrack"
1476
1477   }
1478
1479   AliESDfriend *fr = (AliESDfriend*)(const_cast<AliESDEvent*>(this)->FindFriend());
1480   if (fr) ev->SetVZEROfriend(fr->GetVZEROfriend());
1481 }
1482
1483 //______________________________________________________________________________
1484 void AliESDEvent::AddObject(TObject* obj)
1485 {
1486   // Add an object to the list of object.
1487   // Please be aware that in order to increase performance you should
1488   // refrain from using TObjArrays (if possible). Use TClonesArrays, instead.
1489   fESDObjects->SetOwner(kTRUE);
1490   fESDObjects->AddLast(obj);
1491 }
1492
1493 //______________________________________________________________________________
1494 void AliESDEvent::GetStdContent()
1495 {
1496   // set pointers for standard content
1497   // get by name much safer and not a big overhead since not called very often
1498
1499   fESDRun = (AliESDRun*)fESDObjects->FindObject(fgkESDListName[kESDRun]);
1500   fHeader = (AliESDHeader*)fESDObjects->FindObject(fgkESDListName[kHeader]);
1501   fESDZDC = (AliESDZDC*)fESDObjects->FindObject(fgkESDListName[kESDZDC]);
1502   fESDFMD = (AliESDFMD*)fESDObjects->FindObject(fgkESDListName[kESDFMD]);
1503   fESDVZERO = (AliESDVZERO*)fESDObjects->FindObject(fgkESDListName[kESDVZERO]);
1504   fESDTZERO = (AliESDTZERO*)fESDObjects->FindObject(fgkESDListName[kESDTZERO]);
1505   fTPCVertex = (AliESDVertex*)fESDObjects->FindObject(fgkESDListName[kTPCVertex]);
1506   fSPDVertex = (AliESDVertex*)fESDObjects->FindObject(fgkESDListName[kSPDVertex]);
1507   fPrimaryVertex = (AliESDVertex*)fESDObjects->FindObject(fgkESDListName[kPrimaryVertex]);
1508   fSPDMult =       (AliMultiplicity*)fESDObjects->FindObject(fgkESDListName[kSPDMult]);
1509   fPHOSTrigger = (AliESDCaloTrigger*)fESDObjects->FindObject(fgkESDListName[kPHOSTrigger]);
1510   fEMCALTrigger = (AliESDCaloTrigger*)fESDObjects->FindObject(fgkESDListName[kEMCALTrigger]);
1511   fSPDPileupVertices = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kSPDPileupVertices]);
1512   fTrkPileupVertices = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kTrkPileupVertices]);
1513   fTracks = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kTracks]);
1514   fMuonTracks = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kMuonTracks]);
1515   fMuonClusters = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kMuonClusters]);
1516   fMuonPads = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kMuonPads]);
1517   fMuonGlobalTracks = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kMuonGlobalTracks]);         // AU
1518   fPmdTracks = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kPmdTracks]);
1519   fTrdTrigger = (AliESDTrdTrigger*)fESDObjects->FindObject(fgkESDListName[kTrdTrigger]);
1520   fTrdTracks = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kTrdTracks]);
1521   fTrdTracklets = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kTrdTracklets]);
1522   fV0s = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kV0s]);
1523   fCascades = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kCascades]);
1524   fKinks = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kKinks]);
1525   fCaloClusters = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kCaloClusters]);
1526   fEMCALCells = (AliESDCaloCells*)fESDObjects->FindObject(fgkESDListName[kEMCALCells]);
1527   fPHOSCells = (AliESDCaloCells*)fESDObjects->FindObject(fgkESDListName[kPHOSCells]);
1528   fErrorLogs = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kErrorLogs]);
1529   fESDACORDE = (AliESDACORDE*)fESDObjects->FindObject(fgkESDListName[kESDACORDE]);
1530   fESDAD = (AliESDAD*)fESDObjects->FindObject(fgkESDListName[kESDAD]);
1531   fTOFHeader = (AliTOFHeader*)fESDObjects->FindObject(fgkESDListName[kTOFHeader]);
1532   fCosmicTracks = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kCosmicTracks]);
1533   fESDTOFClusters = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kTOFclusters]);
1534   fESDTOFHits = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kTOFhit]);
1535   fESDTOFMatches = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kTOFmatch]);
1536 }
1537
1538 //______________________________________________________________________________
1539 void AliESDEvent::SetStdNames(){
1540   // Set the names of the standard contents
1541   //
1542   if(fESDObjects->GetEntries()>=kESDListN){
1543     for(int i = 0;i < fESDObjects->GetEntries() && i<kESDListN;i++){
1544       TObject *fObj = fESDObjects->At(i);
1545       if(fObj->InheritsFrom("TNamed")){
1546         ((TNamed*)fObj)->SetName(fgkESDListName[i]);
1547       }
1548       else if(fObj->InheritsFrom("TClonesArray")){
1549         ((TClonesArray*)fObj)->SetName(fgkESDListName[i]);
1550       }
1551     }
1552   }
1553   else{
1554      AliWarning("Std Entries missing");
1555   }
1556 }
1557
1558 //______________________________________________________________________________
1559 void AliESDEvent::CreateStdContent(Bool_t bUseThisList){
1560   fUseOwnList = bUseThisList;
1561   CreateStdContent();
1562 }
1563
1564 //______________________________________________________________________________
1565 void AliESDEvent::CreateStdContent()
1566 {
1567   // create the standard AOD content and set pointers
1568
1569   // create standard objects and add them to the TList of objects
1570   AddObject(new AliESDRun());
1571   AddObject(new AliESDHeader());
1572   AddObject(new AliESDZDC());
1573   AddObject(new AliESDFMD());
1574   AddObject(new AliESDVZERO());
1575   AddObject(new AliESDTZERO());
1576   AddObject(new AliESDVertex());
1577   AddObject(new AliESDVertex());
1578   AddObject(new AliESDVertex());
1579   AddObject(new AliMultiplicity());
1580   AddObject(new AliESDCaloTrigger());
1581   AddObject(new AliESDCaloTrigger());
1582   AddObject(new TClonesArray("AliESDVertex",0));
1583   AddObject(new TClonesArray("AliESDVertex",0));
1584   AddObject(new TClonesArray("AliESDtrack",0));
1585   AddObject(new TClonesArray("AliESDMuonTrack",0));
1586   AddObject(new TClonesArray("AliESDMuonCluster",0));
1587   AddObject(new TClonesArray("AliESDMuonPad",0));
1588   AddObject(new TClonesArray("AliESDMuonGlobalTrack",0));   // AU
1589   AddObject(new TClonesArray("AliESDPmdTrack",0));
1590   AddObject(new AliESDTrdTrigger());
1591   AddObject(new TClonesArray("AliESDTrdTrack",0));
1592   AddObject(new TClonesArray("AliESDTrdTracklet",0));
1593   AddObject(new TClonesArray("AliESDv0",0));
1594   AddObject(new TClonesArray("AliESDcascade",0));
1595   AddObject(new TClonesArray("AliESDkink",0));
1596   AddObject(new TClonesArray("AliESDCaloCluster",0));
1597   AddObject(new AliESDCaloCells());
1598   AddObject(new AliESDCaloCells());
1599   AddObject(new TClonesArray("AliRawDataErrorLog",0));
1600   AddObject(new AliESDACORDE());
1601   AddObject(new AliESDAD());
1602   AddObject(new AliTOFHeader());
1603   AddObject(new TClonesArray("AliESDCosmicTrack",0));
1604   AddObject(new TClonesArray("AliESDTOFCluster",0));
1605   AddObject(new TClonesArray("AliESDTOFHit",0));
1606   AddObject(new TClonesArray("AliESDTOFMatch",0));
1607
1608   // check the order of the indices against enum...
1609
1610   // set names
1611   SetStdNames();
1612   // read back pointers
1613   GetStdContent();
1614 }
1615
1616 //______________________________________________________________________________
1617 void AliESDEvent::CompleteStdContent()
1618 {
1619   // Create missing standard objects and add them to the TList of objects
1620   //
1621   // Add cosmic tracks for cases where esd files were created
1622   // before adding them to the std content
1623   if (!fESDObjects->FindObject(fgkESDListName[kCosmicTracks])) {
1624     TClonesArray* cosmics = new TClonesArray("AliESDCosmicTrack",0);
1625     fESDObjects->AddAt(cosmics, kCosmicTracks);
1626     fESDObjects->SetOwner(kTRUE);
1627   }
1628   // Add new MUON containers if missing (for backward compatibility)
1629   if (!fESDObjects->FindObject(fgkESDListName[kMuonClusters])) {
1630     TClonesArray* muonClusters = new TClonesArray("AliESDMuonCluster",0);
1631     muonClusters->SetName(fgkESDListName[kMuonClusters]);
1632     fESDObjects->AddAt(muonClusters, kMuonClusters);
1633     fESDObjects->SetOwner(kTRUE);
1634   }
1635   if (!fESDObjects->FindObject(fgkESDListName[kMuonPads])) {
1636     TClonesArray* muonPads = new TClonesArray("AliESDMuonPad",0);
1637     muonPads->SetName(fgkESDListName[kMuonPads]);
1638     fESDObjects->AddAt(muonPads, kMuonPads);
1639     fESDObjects->SetOwner(kTRUE);
1640   }
1641 }
1642
1643 //______________________________________________________________________________
1644 TObject* AliESDEvent::FindListObject(const char *name) const {
1645 //
1646 // Find object with name "name" in the list of branches
1647 //
1648   if(fESDObjects){
1649     return fESDObjects->FindObject(name);
1650   }
1651   return 0;
1652 }
1653
1654 //______________________________________________________________________________
1655 Int_t AliESDEvent::GetPHOSClusters(TRefArray *clusters) const
1656 {
1657   // fills the provided TRefArray with all found phos clusters
1658
1659   clusters->Clear();
1660
1661   AliESDCaloCluster *cl = 0;
1662   for (Int_t i = 0; i < GetNumberOfCaloClusters(); i++) {
1663
1664     if ( (cl = GetCaloCluster(i)) ) {
1665       if (cl->IsPHOS()){
1666         clusters->Add(cl);
1667         AliDebug(1,Form("IsPHOS cluster %d Size: %d \n",i,clusters->GetEntriesFast()));
1668       }
1669     }
1670   }
1671   return clusters->GetEntriesFast();
1672 }
1673
1674 //______________________________________________________________________________
1675 Int_t AliESDEvent::GetEMCALClusters(TRefArray *clusters) const
1676 {
1677   // fills the provided TRefArray with all found emcal clusters
1678
1679   clusters->Clear();
1680
1681   AliESDCaloCluster *cl = 0;
1682   for (Int_t i = 0; i < GetNumberOfCaloClusters(); i++) {
1683
1684     if ( (cl = GetCaloCluster(i)) ) {
1685       if (cl->IsEMCAL()){
1686         clusters->Add(cl);
1687         AliDebug(1,Form("IsEMCAL cluster %d Size: %d \n",i,clusters->GetEntriesFast()));
1688       }
1689     }
1690   }
1691   return clusters->GetEntriesFast();
1692 }
1693
1694 //______________________________________________________________________________
1695 void AliESDEvent::WriteToTree(TTree* tree) const {
1696   // Book the branches as in TTree::Branch(TCollection*)
1697   // but add a "." at the end of top level branches which are
1698   // not a TClonesArray
1699
1700
1701   TString branchname;
1702   TIter next(fESDObjects);
1703   const Int_t kSplitlevel = 99; // default value in TTree::Branch()
1704   const Int_t kBufsize = 32000; // default value in TTree::Branch()
1705   TObject *obj = 0;
1706
1707   while ((obj = next())) {
1708     branchname.Form("%s", obj->GetName());
1709     if(branchname.CompareTo("AliESDfriend")==0)branchname = "ESDfriend.";
1710     if ((kSplitlevel > 1) &&  !obj->InheritsFrom(TClonesArray::Class())) {
1711       if(!branchname.EndsWith("."))branchname += ".";
1712     }
1713     if (!tree->FindBranch(branchname)) {
1714       // For the custom streamer to be called splitlevel
1715       // has to be negative, only needed for HLT
1716       Int_t splitLevel = (TString(obj->ClassName()) == "AliHLTGlobalTriggerDecision") ? -1 : kSplitlevel - 1;
1717       tree->Bronch(branchname, obj->ClassName(), fESDObjects->GetObjectRef(obj),kBufsize, splitLevel);
1718     }
1719   }
1720
1721   tree->Branch("fDetectorStatus",(void*)&fDetectorStatus,"fDetectorStatus/l");
1722   tree->Branch("fDAQDetectorPattern",(void*)&fDAQDetectorPattern,"fDAQDetectorPattern/i");
1723   tree->Branch("fDAQAttributes",(void*)&fDAQAttributes,"fDAQAttributes/i");
1724 }
1725
1726 //______________________________________________________________________________
1727 void AliESDEvent::ReadFromTree(TTree *tree, Option_t* opt){
1728 //
1729 // Connect the ESDEvent to a tree
1730 //
1731   if(!tree){
1732     AliWarning("AliESDEvent::ReadFromTree() Zero Pointer to Tree \n");
1733     return;
1734   }
1735   // load the TTree
1736   if(!tree->GetTree())tree->LoadTree(0);
1737
1738   // if we find the "ESD" branch on the tree we do have the old structure
1739   if(tree->GetBranch("ESD")) {
1740     fOldMuonStructure = kFALSE;
1741     char ** address  = (char **)(tree->GetBranch("ESD")->GetAddress());
1742     // do we have the friend branch
1743     TBranch * esdFB = tree->GetBranch("ESDfriend.");
1744     char ** addressF = 0;
1745     if(esdFB)addressF = (char **)(esdFB->GetAddress());
1746     if (!address) {
1747       AliInfo("AliESDEvent::ReadFromTree() Reading old Tree");
1748       tree->SetBranchAddress("ESD",       &fESDOld);
1749       if(esdFB){
1750         tree->SetBranchAddress("ESDfriend.",&fESDFriendOld);
1751       }
1752     } else {
1753       AliInfo("AliESDEvent::ReadFromTree() Reading old Tree");
1754       AliInfo("Branch already connected. Using existing branch address.");
1755       fESDOld       = (AliESD*)       (*address);
1756       // addressF can still be 0, since branch needs to switched on
1757       if(addressF)fESDFriendOld = (AliESDfriend*) (*addressF);
1758     }
1759
1760     //  have already connected the old ESD structure... ?
1761     // reuse also the pointer of the AlliESDEvent
1762     // otherwise create new ones
1763     TList* connectedList = (TList*) (tree->GetUserInfo()->FindObject("ESDObjectsConnectedToTree"));
1764
1765     if(connectedList){
1766       // If connected use the connected list of objects
1767       if(fESDObjects!= connectedList){
1768         // protect when called twice
1769         fESDObjects->Delete();
1770         fESDObjects = connectedList;
1771       }
1772       GetStdContent();
1773
1774
1775       // The pointer to the friend changes when called twice via InitIO
1776       // since AliESDEvent is deleted
1777       TObject* oldf = FindListObject("AliESDfriend");
1778       TObject* newf = 0;
1779       if(addressF){
1780         newf = (TObject*)*addressF;
1781       }
1782       if(newf!=0&&oldf!=newf){
1783         // remove the old reference
1784         // Should we also delete it? Or is this handled in TTree I/O
1785         // since it is created by the first SetBranchAddress
1786         fESDObjects->Remove(oldf);
1787         // add the new one
1788         fESDObjects->Add(newf);
1789       }
1790
1791       fConnected = true;
1792       return;
1793     }
1794     // else...
1795     CreateStdContent(); // create for copy
1796     // if we have the esdfriend add it, so we always can access it via the userinfo
1797     if(fESDFriendOld)AddObject(fESDFriendOld);
1798     // we are not owner of the list objects
1799     // must not delete it
1800     fESDObjects->SetOwner(kTRUE);
1801     fESDObjects->SetName("ESDObjectsConnectedToTree");
1802     tree->GetUserInfo()->Add(fESDObjects);
1803     fConnected = true;
1804     return;
1805   }
1806
1807
1808     delete fESDOld;
1809     fESDOld = 0;
1810   // Try to find AliESDEvent
1811   AliESDEvent *esdEvent = 0;
1812   esdEvent = (AliESDEvent*)tree->GetTree()->GetUserInfo()->FindObject("AliESDEvent");
1813   if(esdEvent){
1814       // Check if already connected to tree
1815     esdEvent->Reset();
1816     TList* connectedList = (TList*) (tree->GetUserInfo()->FindObject("ESDObjectsConnectedToTree"));
1817
1818
1819     if (connectedList && (strcmp(opt, "reconnect"))) {
1820       // If connected use the connected list if objects
1821       fESDObjects->Delete();
1822       fESDObjects = connectedList;
1823       tree->SetBranchAddress("fDetectorStatus",&fDetectorStatus); //PH probably redundant
1824       tree->SetBranchAddress("fDAQDetectorPattern",&fDAQDetectorPattern);
1825       tree->SetBranchAddress("fDAQAttributes",&fDAQAttributes);
1826       GetStdContent();
1827       fOldMuonStructure = fESDObjects->TestBit(BIT(23));
1828       fConnected = true;
1829       return;
1830     }
1831
1832     // Connect to tree
1833     // prevent a memory leak when reading back the TList
1834     // if (!(strcmp(opt, "reconnect"))) fESDObjects->Delete();
1835
1836     if(!fUseOwnList){
1837       // create a new TList from the UserInfo TList...
1838       // copy constructor does not work...
1839       fESDObjects = (TList*)(esdEvent->GetList()->Clone());
1840       fESDObjects->SetOwner(kTRUE);
1841     }
1842     else if ( fESDObjects->GetEntries()==0){
1843       // at least create the std content if we want to read to our list
1844       CreateStdContent();
1845     }
1846
1847     // in principle
1848     // we only need new things in the list if we do no already have it..
1849     // TODO just add new entries
1850     CompleteStdContent();
1851
1852     if(fESDObjects->GetEntries()<kESDListN){
1853       AliWarning(Form("AliESDEvent::ReadFromTree() TList contains less than the standard contents %d < %d \n",
1854                       fESDObjects->GetEntries(),kESDListN));
1855     }
1856     // set the branch addresses
1857     fOldMuonStructure = kFALSE;
1858     TIter next(fESDObjects);
1859     TNamed *el;
1860     while((el=(TNamed*)next())){
1861       TString bname(el->GetName());
1862       if(bname.CompareTo("AliESDfriend")==0)
1863         {
1864           // AliESDfriend does not have a name ...
1865             TBranch *br = tree->GetBranch("ESDfriend.");
1866             if (br) tree->SetBranchAddress("ESDfriend.",fESDObjects->GetObjectRef(el));
1867         }
1868       else{
1869         // check if branch exists under this Name
1870         TBranch *br = tree->GetBranch(bname.Data());
1871         if(br){
1872           tree->SetBranchAddress(bname.Data(),fESDObjects->GetObjectRef(el));
1873         }
1874         else{
1875           br = tree->GetBranch(Form("%s.",bname.Data()));
1876           if(br){
1877             tree->SetBranchAddress(Form("%s.",bname.Data()),fESDObjects->GetObjectRef(el));
1878           }
1879           else{
1880             AliWarning(Form("AliESDEvent::ReadFromTree() No Branch found with Name %s or %s.",bname.Data(),bname.Data()));
1881             if (bname == fgkESDListName[kMuonClusters]) {
1882               fOldMuonStructure = kTRUE;
1883             }
1884           }
1885
1886         }
1887       }
1888     }
1889     tree->SetBranchAddress("fDetectorStatus",&fDetectorStatus);
1890     tree->SetBranchAddress("fDAQDetectorPattern",&fDAQDetectorPattern);
1891     tree->SetBranchAddress("fDAQAttributes",&fDAQAttributes);
1892
1893     GetStdContent();
1894     // when reading back we are not owner of the list
1895     // must not delete it
1896     fESDObjects->SetOwner(kTRUE);
1897     fESDObjects->SetName("ESDObjectsConnectedToTree");
1898     fESDObjects->SetBit(BIT(23), fOldMuonStructure);
1899     // we are not owner of the list objects
1900     // must not delete it
1901     tree->GetUserInfo()->Add(fESDObjects);
1902     tree->GetUserInfo()->SetOwner(kFALSE);
1903     fConnected = true;
1904   }// no esdEvent -->
1905   else {
1906     // we can't get the list from the user data, create standard content
1907     // and set it by hand (no ESDfriend at the moment
1908     CreateStdContent();
1909     fOldMuonStructure = kFALSE;
1910     TIter next(fESDObjects);
1911     TNamed *el;
1912     while((el=(TNamed*)next())){
1913       TString bname(el->GetName());
1914       TBranch *br = tree->GetBranch(bname.Data());
1915       if(br){
1916         tree->SetBranchAddress(bname.Data(),fESDObjects->GetObjectRef(el));
1917       }
1918       else{
1919         br = tree->GetBranch(Form("%s.",bname.Data()));
1920         if(br){
1921           tree->SetBranchAddress(Form("%s.",bname.Data()),fESDObjects->GetObjectRef(el));
1922         }
1923         else if (bname == fgkESDListName[kMuonClusters]) {
1924           fOldMuonStructure = kTRUE;
1925         }
1926       }
1927     }
1928     tree->SetBranchAddress("fDetectorStatus",&fDetectorStatus);
1929     tree->SetBranchAddress("fDAQDetectorPattern",&fDAQDetectorPattern);
1930     tree->SetBranchAddress("fDAQAttributes",&fDAQAttributes);
1931
1932     GetStdContent();
1933     // when reading back we are not owner of the list
1934     // must not delete it
1935     fESDObjects->SetOwner(kTRUE);
1936   }
1937 }
1938
1939 //______________________________________________________________________________
1940 void AliESDEvent::CopyFromOldESD()
1941 {
1942   // Method which copies over everthing from the old esd structure to the
1943   // new
1944   if(fESDOld){
1945     ResetStdContent();
1946      // Run
1947     SetRunNumber(fESDOld->GetRunNumber());
1948     SetPeriodNumber(fESDOld->GetPeriodNumber());
1949     SetMagneticField(fESDOld->GetMagneticField());
1950
1951     // leave out diamond ...
1952     // SetDiamond(const AliESDVertex *vertex) { fESDRun->SetDiamond(vertex);}
1953
1954     // header
1955     SetTriggerMask(fESDOld->GetTriggerMask());
1956     SetOrbitNumber(fESDOld->GetOrbitNumber());
1957     SetTimeStamp(fESDOld->GetTimeStamp());
1958     SetEventType(fESDOld->GetEventType());
1959     SetEventNumberInFile(fESDOld->GetEventNumberInFile());
1960     SetBunchCrossNumber(fESDOld->GetBunchCrossNumber());
1961     SetTriggerCluster(fESDOld->GetTriggerCluster());
1962
1963     // ZDC
1964
1965     SetZDC(fESDOld->GetZDCN1Energy(),
1966            fESDOld->GetZDCP1Energy(),
1967            fESDOld->GetZDCEMEnergy(),
1968            0,
1969            fESDOld->GetZDCN2Energy(),
1970            fESDOld->GetZDCP2Energy(),
1971            fESDOld->GetZDCParticipants(),
1972            0,
1973            0,
1974            0,
1975            0,
1976            0,
1977            0);
1978
1979     // FMD
1980
1981     if(fESDOld->GetFMDData())SetFMDData(fESDOld->GetFMDData());
1982
1983     // T0
1984
1985     SetT0zVertex(fESDOld->GetT0zVertex());
1986     SetT0(fESDOld->GetT0());
1987     //  leave amps out
1988
1989     // VZERO
1990     if (fESDOld->GetVZEROData()) SetVZEROData(fESDOld->GetVZEROData());
1991
1992     if(fESDOld->GetVertex())SetPrimaryVertexSPD(fESDOld->GetVertex());
1993
1994     if(fESDOld->GetPrimaryVertex())SetPrimaryVertexTracks(fESDOld->GetPrimaryVertex());
1995
1996     if(fESDOld->GetMultiplicity())SetMultiplicity(fESDOld->GetMultiplicity());
1997
1998     for(int i = 0;i<fESDOld->GetNumberOfTracks();i++){
1999       AddTrack(fESDOld->GetTrack(i));
2000     }
2001
2002     for(int i = 0;i<fESDOld->GetNumberOfMuonTracks();i++){
2003       AddMuonTrack(fESDOld->GetMuonTrack(i));
2004     }
2005
2006     for(int i = 0;i<fESDOld->GetNumberOfPmdTracks();i++){
2007       AddPmdTrack(fESDOld->GetPmdTrack(i));
2008     }
2009
2010     for(int i = 0;i<fESDOld->GetNumberOfTrdTracks();i++){
2011       AddTrdTrack(fESDOld->GetTrdTrack(i));
2012     }
2013
2014     for(int i = 0;i<fESDOld->GetNumberOfV0s();i++){
2015       AddV0(fESDOld->GetV0(i));
2016     }
2017
2018     for(int i = 0;i<fESDOld->GetNumberOfCascades();i++){
2019       AddCascade(fESDOld->GetCascade(i));
2020     }
2021
2022     for(int i = 0;i<fESDOld->GetNumberOfKinks();i++){
2023       AddKink(fESDOld->GetKink(i));
2024     }
2025
2026
2027     for(int i = 0;i<fESDOld->GetNumberOfCaloClusters();i++){
2028       AddCaloCluster(fESDOld->GetCaloCluster(i));
2029     }
2030
2031   }// if fesdold
2032 }
2033
2034 //______________________________________________________________________________
2035 Bool_t AliESDEvent::IsEventSelected(const char *trigExpr) const
2036 {
2037   // Check if the event satisfies the trigger
2038   // selection expression trigExpr.
2039   // trigExpr can be any logical expression
2040   // of the trigger classes defined in AliESDRun
2041   // In case of wrong syntax return kTRUE.
2042   // Modified by rl for 100 classes - to be tested
2043
2044   TString expr(trigExpr);
2045   if (expr.IsNull()) return kTRUE;
2046
2047   ULong64_t mask = GetTriggerMask();
2048   for(Int_t itrig = 0; itrig < AliESDRun::kNTriggerClasses/2; itrig++) {
2049     if (mask & (1ull << itrig)) {
2050       expr.ReplaceAll(GetESDRun()->GetTriggerClass(itrig),"1");
2051     }
2052     else {
2053       expr.ReplaceAll(GetESDRun()->GetTriggerClass(itrig),"0");
2054     }
2055   }
2056   ULong64_t maskNext50 = GetTriggerMaskNext50();
2057   for(Int_t itrig = 0; itrig < AliESDRun::kNTriggerClasses/2; itrig++) {
2058     if (maskNext50 & (1ull << itrig)) {
2059       expr.ReplaceAll(GetESDRun()->GetTriggerClass(itrig+50),"1");
2060     }
2061     else {
2062       expr.ReplaceAll(GetESDRun()->GetTriggerClass(itrig+50),"0");
2063     }
2064   }
2065
2066   Int_t error;
2067   if ((gROOT->ProcessLineFast(expr.Data(),&error) == 0) &&
2068       (error == TInterpreter::kNoError)) {
2069     return kFALSE;
2070   }
2071
2072   return kTRUE;
2073
2074 }
2075
2076 //______________________________________________________________________________
2077 TObject*  AliESDEvent::GetHLTTriggerDecision() const
2078 {
2079   // get the HLT trigger decission object
2080
2081   // cast away const'nes because the FindListObject method
2082   // is not const
2083   AliESDEvent* pNonConst=const_cast<AliESDEvent*>(this);
2084   return pNonConst->FindListObject("HLTGlobalTrigger");
2085 }
2086
2087 TString   AliESDEvent::GetHLTTriggerDescription() const
2088 {
2089   // get the HLT trigger decission description
2090   TString description;
2091   TObject* pDecision=GetHLTTriggerDecision();
2092   if (pDecision) {
2093     description=pDecision->GetTitle();
2094   }
2095
2096   return description;
2097 }
2098
2099 //______________________________________________________________________________
2100 Bool_t    AliESDEvent::IsHLTTriggerFired(const char* name) const
2101 {
2102   // get the HLT trigger decission description
2103   TObject* pDecision=GetHLTTriggerDecision();
2104   if (!pDecision) return kFALSE;
2105
2106   Option_t* option=pDecision->GetOption();
2107   if (option==NULL || *option!='1') return kFALSE;
2108
2109   if (name) {
2110     TString description=GetHLTTriggerDescription();
2111     Int_t index=description.Index(name);
2112     if (index<0) return kFALSE;
2113     index+=strlen(name);
2114     if (index>=description.Length()) return kFALSE;
2115     if (description[index]!=0 && description[index]!=' ') return kFALSE;
2116   }
2117   return kTRUE;
2118 }
2119
2120 //______________________________________________________________________________
2121 Bool_t  AliESDEvent::IsPileupFromSPD(Int_t minContributors,
2122                                      Double_t minZdist,
2123                                      Double_t nSigmaZdist,
2124                                      Double_t nSigmaDiamXY,
2125                                      Double_t nSigmaDiamZ) const{
2126   //
2127   // This function checks if there was a pile up
2128   // reconstructed with SPD
2129   //
2130   Int_t nc1=fSPDVertex->GetNContributors();
2131   if(nc1<1) return kFALSE;
2132   Int_t nPileVert=GetNumberOfPileupVerticesSPD();
2133   if(nPileVert==0) return kFALSE;
2134
2135   for(Int_t i=0; i<nPileVert;i++){
2136     const AliESDVertex* pv=GetPileupVertexSPD(i);
2137     Int_t nc2=pv->GetNContributors();
2138     if(nc2>=minContributors){
2139       Double_t z1=fSPDVertex->GetZ();
2140       Double_t z2=pv->GetZ();
2141       Double_t distZ=TMath::Abs(z2-z1);
2142       Double_t distZdiam=TMath::Abs(z2-GetDiamondZ());
2143       Double_t cutZdiam=nSigmaDiamZ*TMath::Sqrt(GetSigma2DiamondZ());
2144       if(GetSigma2DiamondZ()<0.0001)cutZdiam=99999.; //protection for missing z diamond information
2145       if(distZ>minZdist && distZdiam<cutZdiam){
2146         Double_t x2=pv->GetX();
2147         Double_t y2=pv->GetY();
2148         Double_t distXdiam=TMath::Abs(x2-GetDiamondX());
2149         Double_t distYdiam=TMath::Abs(y2-GetDiamondY());
2150         Double_t cov1[6],cov2[6];
2151         fSPDVertex->GetCovarianceMatrix(cov1);
2152         pv->GetCovarianceMatrix(cov2);
2153         Double_t errxDist=TMath::Sqrt(cov2[0]+GetSigma2DiamondX());
2154         Double_t erryDist=TMath::Sqrt(cov2[2]+GetSigma2DiamondY());
2155         Double_t errzDist=TMath::Sqrt(cov1[5]+cov2[5]);
2156         Double_t cutXdiam=nSigmaDiamXY*errxDist;
2157         if(GetSigma2DiamondX()<0.0001)cutXdiam=99999.; //protection for missing diamond information
2158         Double_t cutYdiam=nSigmaDiamXY*erryDist;
2159         if(GetSigma2DiamondY()<0.0001)cutYdiam=99999.; //protection for missing diamond information
2160         if( (distXdiam<cutXdiam) && (distYdiam<cutYdiam) && (distZ>nSigmaZdist*errzDist) ){
2161           return kTRUE;
2162         }
2163       }
2164     }
2165   }
2166   return kFALSE;
2167 }
2168
2169 //______________________________________________________________________________
2170 void AliESDEvent::EstimateMultiplicity(Int_t &tracklets, Int_t &trITSTPC, Int_t &trITSSApure, Double_t eta, Bool_t useDCAFlag,Bool_t useV0Flag) const
2171 {
2172   //
2173   // calculates 3 estimators for the multiplicity in the -eta:eta range
2174   // tracklets   : using SPD tracklets only
2175   // trITSTPC    : using TPC/ITS + complementary ITS SA tracks + tracklets from clusters not used by tracks
2176   // trITSSApure : using ITS standalone tracks + tracklets from clusters not used by tracks
2177   // if useDCAFlag is true: account for the ESDtrack flag marking the tracks with large DCA
2178   // if useV0Flag  is true: account for the ESDtrack flag marking conversion and K0's V0s
2179
2180   AliWarning("This obsolete method will be eliminated soon. Use AliESDtrackCuts::GetReferenceMultiplicity");
2181
2182   tracklets = trITSSApure = trITSTPC = 0;
2183   int ntr = fSPDMult ? fSPDMult->GetNumberOfTracklets() : 0;
2184   //
2185   // count tracklets
2186   for (int itr=ntr;itr--;) {
2187     if (TMath::Abs(fSPDMult->GetEta(itr))>eta) continue;
2188     tracklets++;
2189     if (fSPDMult->FreeClustersTracklet(itr,0)) trITSTPC++;    // not used in ITS/TPC or ITS_SA track
2190     if (fSPDMult->FreeClustersTracklet(itr,1)) trITSSApure++; // not used in ITS_SA_Pure track
2191   }
2192   //
2193   // count real tracks
2194   ntr = GetNumberOfTracks();
2195   for (int itr=ntr;itr--;) {
2196     AliESDtrack *t = GetTrack(itr);
2197     if (!t) {AliFatal(Form("NULL pointer for ESD track %d",itr));}
2198     if (TMath::Abs(t->Eta())>eta) continue;
2199     if (!t->IsOn(AliESDtrack::kITSin)) continue;
2200     if (useDCAFlag && t->IsOn(AliESDtrack::kMultSec))  continue;
2201     if (useV0Flag  && t->IsOn(AliESDtrack::kMultInV0)) continue;
2202     if (t->IsOn(AliESDtrack::kITSpureSA)) trITSSApure++;
2203     else                                  trITSTPC++;
2204   }
2205   //
2206 }
2207
2208 //______________________________________________________________________________
2209 Bool_t AliESDEvent::IsPileupFromSPDInMultBins() const {
2210     Int_t nTracklets=GetMultiplicity()->GetNumberOfTracklets();
2211     if(nTracklets<20) return IsPileupFromSPD(3,0.8);
2212     else if(nTracklets<50) return IsPileupFromSPD(4,0.8);
2213     else return IsPileupFromSPD(5,0.8);
2214 }
2215
2216 //______________________________________________________________________________
2217 void  AliESDEvent::SetTOFHeader(const AliTOFHeader *header)
2218 {
2219   //
2220   // Set the TOF event_time
2221   //
2222
2223   if (fTOFHeader) {
2224     *fTOFHeader=*header;
2225     //fTOFHeader->SetName(fgkESDListName[kTOFHeader]);
2226   }
2227   else {
2228     // for analysis of reconstructed events
2229     // when this information is not avaliable
2230     fTOFHeader = new AliTOFHeader(*header);
2231     //AddObject(fTOFHeader);
2232   }
2233
2234 }
2235
2236 //______________________________________________________________________________
2237 AliCentrality* AliESDEvent::GetCentrality()
2238 {
2239     if (!fCentrality) fCentrality = new AliCentrality();
2240     return  fCentrality;
2241 }
2242
2243 //______________________________________________________________________________
2244 AliEventplane* AliESDEvent::GetEventplane()
2245 {
2246     if (!fEventplane) fEventplane = new AliEventplane();
2247     return  fEventplane;
2248 }
2249
2250 //______________________________________________________________________________
2251 Float_t AliESDEvent::GetVZEROEqMultiplicity(Int_t i) const
2252 {
2253   // Get VZERO Multiplicity for channel i
2254   // Themethod uses the equalization factors
2255   // stored in the ESD-run object in order to
2256   // get equal multiplicities within a VZERO rins (1/8 of VZERO)
2257   if (!fESDVZERO || !fESDRun) return -1;
2258
2259   Int_t ring = i/8;
2260   Float_t factorSum = 0;
2261   for(Int_t j = 8*ring; j < (8*ring+8); ++j) {
2262     factorSum += fESDRun->GetVZEROEqFactors(j);
2263   }
2264   Float_t factor = fESDRun->GetVZEROEqFactors(i)*8./factorSum;
2265
2266   return (fESDVZERO->GetMultiplicity(i)/factor);
2267 }
2268
2269 //______________________________________________________________________________
2270 void AliESDEvent::SetTOFcluster(Int_t ntofclusters,AliESDTOFCluster *cluster,Int_t *mapping)
2271 {
2272   // Reset TClonesArray of TOF clusters
2273   if (!fESDTOFClusters) {
2274     AliError("fESDTOFClusters is not initialized");
2275     return;
2276   }
2277   fESDTOFClusters->Clear();
2278
2279   Int_t goodhit[20000];
2280   if(mapping){
2281     for(Int_t i=0;i < 20000;i++){
2282       goodhit[i] = 0;
2283     }
2284   }
2285
2286   for(Int_t i=0;i < ntofclusters;i++){
2287
2288     if(cluster[i].GetNMatchableTracks() || !mapping){
2289       if(mapping)
2290         mapping[i] = fESDTOFClusters->GetEntriesFast();
2291
2292       // update TClonesArray
2293       TClonesArray &ftr = *fESDTOFClusters;
2294       AliESDTOFCluster *clusterTBW = new(ftr[fESDTOFClusters->GetEntriesFast()])AliESDTOFCluster(cluster[i]);
2295
2296       if(mapping){
2297         // loop over hit in the cluster
2298         for(Int_t k=0;k < clusterTBW->GetNTOFhits();k++){
2299           Int_t ipos = clusterTBW->GetHitIndex(k);
2300           goodhit[ipos] = 1; // hit should be kept
2301         }
2302       }
2303     }
2304   }
2305
2306   if(mapping){
2307     AliInfo(Form("TOF cluster before of matching = %i , after = %i\n",ntofclusters,fESDTOFClusters->GetEntriesFast()));
2308     Int_t hitnewpos[20000]={0};
2309     Int_t nhitOriginal = fESDTOFHits->GetEntries();
2310     for(Int_t i=0;i < fESDTOFHits->GetEntries();i++){
2311       if(goodhit[i]){
2312         hitnewpos[i] = i;
2313       }
2314       else{ // remove hit and decrease the hit array
2315         TClonesArray &a=*fESDTOFHits;
2316         Int_t lastpos = fESDTOFHits->GetEntries()-1;
2317
2318         if(i == lastpos)
2319           delete a.RemoveAt(i);
2320         else{
2321           Int_t nhitBefore = fESDTOFHits->GetEntries();
2322           for(Int_t k=nhitBefore-1;k>i;k--){ // find the last good track
2323             if(!goodhit[k]){ // remove track
2324               delete a.RemoveAt(k);
2325               if(k-i==1) delete a.RemoveAt(i);
2326             }
2327             else{ // replace last one to the "i"
2328               AliESDTOFHit *last = (AliESDTOFHit *) fESDTOFHits->At(k);
2329               delete a.RemoveAt(i);
2330               new (a[i]) AliESDTOFHit(*last);
2331               delete a.RemoveAt(k);
2332               hitnewpos[k] = i;
2333               k = 0;
2334             }
2335           }
2336         }
2337       }
2338     }
2339
2340     // remap cluster to hits
2341     for(Int_t i=0;i < fESDTOFClusters->GetEntries();i++){
2342       AliESDTOFCluster *cl = (AliESDTOFCluster *) fESDTOFClusters->At(i);
2343       // loop over hit in the cluster
2344       for(Int_t k=0;k < cl->GetNTOFhits();k++){
2345         cl->SetHitIndex(k,hitnewpos[cl->GetHitIndex(k)]);
2346       }
2347     }
2348     AliInfo(Form("TOF hit before of matching = %i , after = %i\n",nhitOriginal,fESDTOFHits->GetEntriesFast()));
2349   } // end mapping
2350
2351 }
2352
2353 //______________________________________________________________________________
2354 void AliESDEvent::SetTOFcluster(Int_t ntofclusters,AliESDTOFCluster *cluster[],Int_t *mapping)
2355 {
2356   // Reset TClonesArray of TOF clusters
2357   if(fESDTOFClusters)fESDTOFClusters->Delete();
2358
2359   Int_t goodhit[20000];
2360   if(mapping){
2361     for(Int_t i=0;i < 20000;i++){
2362       goodhit[i] = 0;
2363     }
2364   }
2365
2366   for(Int_t i=0;i < ntofclusters;i++){
2367
2368     if(cluster[i]->GetNMatchableTracks() || !mapping){
2369       if(mapping)
2370         mapping[i] = fESDTOFClusters->GetEntriesFast();
2371
2372       // update TClonesArray
2373       TClonesArray &ftr = *fESDTOFClusters;
2374       AliESDTOFCluster *clusterTBW = new(ftr[fESDTOFClusters->GetEntriesFast()])AliESDTOFCluster(*(cluster[i]));
2375
2376       if(mapping){
2377         // loop over hit in the cluster
2378         for(Int_t k=0;k < clusterTBW->GetNTOFhits();k++){
2379           Int_t ipos = clusterTBW->GetHitIndex(k);
2380           goodhit[ipos] = 1; // hit should be kept
2381         }
2382       }
2383     }
2384   }
2385
2386   if(mapping){
2387     AliInfo(Form("TOF cluster before of matching = %i , after = %i\n",ntofclusters,fESDTOFClusters->GetEntriesFast()));
2388     Int_t hitnewpos[20000]={0};
2389     Int_t nhitOriginal = fESDTOFHits->GetEntries();
2390     for(Int_t i=0;i < fESDTOFHits->GetEntries();i++){
2391       if(goodhit[i]){
2392         hitnewpos[i] = i;
2393       }
2394       else{ // remove hit and decrease the hit array
2395         TClonesArray &a=*fESDTOFHits;
2396         Int_t lastpos = fESDTOFHits->GetEntries()-1;
2397
2398         if(i == lastpos)
2399           delete a.RemoveAt(i);
2400         else{
2401           Int_t nhitBefore = fESDTOFHits->GetEntries();
2402           for(Int_t k=nhitBefore-1;k>i;k--){ // find the last good track
2403             if(!goodhit[k]){ // remove track
2404               delete a.RemoveAt(k);
2405               if(k-i==1) delete a.RemoveAt(i);
2406             }
2407             else{ // replace last one to the "i"
2408               AliESDTOFHit *last = (AliESDTOFHit *) fESDTOFHits->At(k);
2409               delete a.RemoveAt(i);
2410               new (a[i]) AliESDTOFHit(*last);
2411               delete a.RemoveAt(k);
2412               hitnewpos[k] = i;
2413               k = 0;
2414             }
2415           }
2416         }
2417       }
2418     }
2419
2420     // remap cluster to hits
2421     for(Int_t i=0;i < fESDTOFClusters->GetEntries();i++){
2422       AliESDTOFCluster *cl = (AliESDTOFCluster *) fESDTOFClusters->At(i);
2423       // loop over hit in the cluster
2424       for(Int_t k=0;k < cl->GetNTOFhits();k++){
2425         cl->SetHitIndex(k,hitnewpos[cl->GetHitIndex(k)]);
2426       }
2427     }
2428     AliInfo(Form("TOF hit before of matching = %i , after = %i\n",nhitOriginal,fESDTOFHits->GetEntriesFast()));
2429   } // end mapping
2430
2431 }
2432
2433 //______________________________________________________________________________
2434 void AliESDEvent::ConnectTracks() {
2435 // Connect tracks to this event
2436   if (fTracksConnected || !fTracks || !fTracks->GetEntriesFast()) return;
2437   AliESDtrack *track;
2438   TIter next(fTracks);
2439   while ((track=(AliESDtrack*)next())) track->SetESDEvent(this);
2440   //
2441   // The same for TOF clusters
2442   if (fESDTOFClusters) {
2443     AliESDTOFCluster *clus;
2444     TIter nextTOF(fESDTOFClusters);
2445     while ((clus=(AliESDTOFCluster*)nextTOF())) clus->SetEvent((AliVEvent *) this);
2446   }
2447   fTracksConnected = kTRUE;
2448   //
2449 }
2450
2451 //______________________________________________________________________________
2452 AliESDfriend* AliESDEvent::FindFriend() const
2453 {
2454   return static_cast<AliESDfriend*>(FindListObject("AliESDfriend"));
2455 }
2456
2457 AliVEvent::EDataLayoutType AliESDEvent::GetDataLayoutType() const {return AliVEvent::kESD;}
2458