STEER/CreateAODfromESD.C

   1 #if !defined(__CINT__) || defined(__MAKECINT__)
   2
   3 #include <Riostream.h>
   4 #include <TFile.h>
   5 #include <TTree.h>
   6 #include <TMath.h>
   7
   8 #include "AliAODEvent.h"
   9 #include "AliAODHeader.h"
  10 #include "AliAODVertex.h"
  11 #include "AliAODTrack.h"
  12 #include "AliAODCluster.h"
  13
  14 #include "AliESD.h"
  15 #include "AliESDtrack.h"
  16 #include "AliESDMuonTrack.h"
  17 #include "AliESDVertex.h"
  18 #include "AliESDv0.h"
  19 #include "AliESDcascade.h"
  20 #include "AliESDCaloCluster.h"
  21
  22 #endif
  23
  24 void CreateAODfromESD(const char *inFileName = "AliESDs.root",
  25                       const char *outFileName = "AliAOD.root") {
  26
  27   // create an AliAOD object
  28   AliAODEvent *aod = new AliAODEvent();
  29   aod->CreateStdContent();
  30
  31   // open the file
  32   TFile *outFile = TFile::Open(outFileName, "RECREATE");
  33
  34   // create the tree
  35   TTree *aodTree = new TTree("AOD", "AliAOD tree");
  36   aodTree->Branch(aod->GetList());
  37
  38   // connect to ESD
  39   TFile *inFile = TFile::Open(inFileName, "READ");
  40   TTree *t = (TTree*) inFile->Get("esdTree");
  41   TBranch *b = t->GetBranch("ESD");
  42   AliESD *esd = 0;
  43   b->SetAddress(&esd);
  44
  45   Int_t nEvents = b->GetEntries();
  46
  47   // set arrays and pointers
  48   Float_t posF[3];
  49   Double_t pos[3];
  50   Double_t p[3];
  51   Double_t covVtx[6];
  52   Double_t covTr[21];
  53   Double_t pid[10];
  54
  55   // loop over events and fill them
  56   for (Int_t iEvent = 0; iEvent < nEvents; ++iEvent) {
  57     b->GetEntry(iEvent);
  58
  59     // Multiplicity information needed by the header (to be revised!)
  60     Int_t nTracks   = esd->GetNumberOfTracks();
  61     Int_t nPosTracks = 0;
  62     for (Int_t iTrack=0; iTrack<nTracks; ++iTrack)
  63       if (esd->GetTrack(iTrack)->GetSign()> 0) nPosTracks++;
  64
  65     // create the header
  66     aod->AddHeader(new AliAODHeader(esd->GetRunNumber(),
  67                                     esd->GetBunchCrossNumber(),
  68                                     esd->GetOrbitNumber(),
  69                                     esd->GetPeriodNumber(),
  70                                     nTracks,
  71                                     nPosTracks,
  72                                     nTracks-nPosTracks,
  73                                     esd->GetMagneticField(),
  74                                     -999., // fill muon magnetic field
  75                                     -999., // centrality; to be filled, still
  76                                     esd->GetZDCN1Energy(),
  77                                     esd->GetZDCP1Energy(),
  78                                     esd->GetZDCN2Energy(),
  79                                     esd->GetZDCP2Energy(),
  80                                     esd->GetZDCEMEnergy(),
  81                                     esd->GetTriggerMask(),
  82                                     esd->GetTriggerCluster(),
  83                                     esd->GetEventType()));
  84
  85     Int_t nV0s      = esd->GetNumberOfV0s();
  86     Int_t nCascades = esd->GetNumberOfCascades();
  87     Int_t nKinks    = esd->GetNumberOfKinks();
  88     Int_t nVertices = nV0s + nCascades + nKinks;
  89
  90     aod->ResetStd(nTracks, nVertices);
  91     AliAODTrack *aodTrack;
  92
  93
  94     // Array to take into account the tracks already added to the AOD
  95     Bool_t * usedTrack = NULL;
  96     if (nTracks>0) {
  97       usedTrack = new Bool_t[nTracks];
  98       for (Int_t iTrack=0; iTrack<nTracks; ++iTrack) usedTrack[iTrack]=kFALSE;
  99     }
 100     // Array to take into account the V0s already added to the AOD
 101     Bool_t * usedV0 = NULL;
 102     if (nV0s>0) {
 103       usedV0 = new Bool_t[nV0s];
 104       for (Int_t iV0=0; iV0<nV0s; ++iV0) usedV0[iV0]=kFALSE;
 105     }
 106     // Array to take into account the kinks already added to the AOD
 107     Bool_t * usedKink = NULL;
 108     if (nKinks>0) {
 109       usedKink = new Bool_t[nKinks];
 110       for (Int_t iKink=0; iKink<nKinks; ++iKink) usedKink[iKink]=kFALSE;
 111     }
 112
 113     // Access to the AOD container of vertices
 114     TClonesArray &vertices = *(aod->GetVertices());
 115     Int_t jVertices=0;
 116
 117     // Access to the AOD container of tracks
 118     TClonesArray &tracks = *(aod->GetTracks());
 119     Int_t jTracks=0;
 120
 121     // Add primary vertex. The primary tracks will be defined
 122     // after the loops on the composite objects (V0, cascades, kinks)
 123     const AliESDVertex *vtx = esd->GetPrimaryVertex();
 124
 125     vtx->GetXYZ(pos); // position
 126     vtx->GetCovMatrix(covVtx); //covariance matrix
 127
 128     AliAODVertex * primary = new(vertices[jVertices++])
 129       AliAODVertex(pos, covVtx, vtx->GetChi2toNDF(), NULL, AliAODVertex::kPrimary);
 130
 131     // Create vertices starting from the most complex objects
 132
 133     // Cascades
 134     for (Int_t nCascade = 0; nCascade < nCascades; ++nCascade) {
 135       AliESDcascade *cascade = esd->GetCascade(nCascade);
 136
 137       cascade->GetXYZ(pos[0], pos[1], pos[2]);
 138       cascade->GetPosCovXi(covVtx);
 139
 140       // Add the cascade vertex
 141       AliAODVertex * vcascade = new(vertices[jVertices++]) AliAODVertex(pos,
 142                                                                         covVtx,
 143                                                                         cascade->GetChi2Xi(), // = chi2/NDF since NDF = 2*2-3
 144                                                                         primary,
 145                                                                         AliAODVertex::kCascade);
 146
 147       primary->AddDaughter(vcascade);
 148
 149       // Add the V0 from the cascade. The ESD class have to be optimized...
 150       // Now we have to search for the corresponding Vo in the list of V0s
 151       // using the indeces of the positive and negative tracks
 152
 153       Int_t posFromV0 = cascade->GetPindex();
 154       Int_t negFromV0 = cascade->GetNindex();
 155
 156
 157       AliESDv0 * v0 = 0x0;
 158       Int_t indV0 = -1;
 159
 160       for (Int_t iV0=0; iV0<nV0s; ++iV0) {
 161
 162         v0 = esd->GetV0(iV0);
 163         Int_t posV0 = v0->GetPindex();
 164         Int_t negV0 = v0->GetNindex();
 165
 166         if (posV0==posFromV0 && negV0==negFromV0) {
 167           indV0 = iV0;
 168           break;
 169         }
 170       }
 171
 172       AliAODVertex * vV0FromCascade = 0x0;
 173
 174       if (indV0>-1 && !usedV0[indV0] ) {
 175
 176         // the V0 exists in the array of V0s and is not used
 177
 178         usedV0[indV0] = kTRUE;
 179
 180         v0->GetXYZ(pos[0], pos[1], pos[2]);
 181         v0->GetPosCov(covVtx);
 182
 183         vV0FromCascade = new(vertices[jVertices++]) AliAODVertex(pos,
 184                                                                  covVtx,
 185                                                                  v0->GetChi2V0(), // = chi2/NDF since NDF = 2*2-3
 186                                                                  vcascade,
 187                                                                  AliAODVertex::kV0);
 188       } else {
 189
 190         // the V0 doesn't exist in the array of V0s or was used
 191         cerr << "Error: event " << iEvent << " cascade " << nCascade
 192              << " The V0 " << indV0
 193              << " doesn't exist in the array of V0s or was used!" << endl;
 194
 195         cascade->GetXYZ(pos[0], pos[1], pos[2]);
 196         cascade->GetPosCov(covVtx);
 197
 198         vV0FromCascade = new(vertices[jVertices++]) AliAODVertex(pos,
 199                                                                  covVtx,
 200                                                                  v0->GetChi2V0(), // = chi2/NDF since NDF = 2*2-3
 201                                                                  vcascade,
 202                                                                  AliAODVertex::kV0);
 203         vcascade->AddDaughter(vV0FromCascade);
 204       }
 205
 206       // Add the positive tracks from the V0
 207
 208       if (! usedTrack[posFromV0]) {
 209
 210         usedTrack[posFromV0] = kTRUE;
 211
 212         AliESDtrack *esdTrack = esd->GetTrack(posFromV0);
 213         esdTrack->GetPxPyPz(p);
 214         esdTrack->GetXYZ(pos);
 215         esdTrack->GetCovarianceXYZPxPyPz(covTr);
 216         esdTrack->GetESDpid(pid);
 217
 218         vV0FromCascade->AddDaughter(aodTrack =
 219                                     new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
 220                                            esdTrack->GetLabel(),
 221                                            p,
 222                                            kTRUE,
 223                                            pos,
 224                                            kFALSE,
 225                                            covTr,
 226                                            (Short_t)esdTrack->GetSign(),
 227                                            esdTrack->GetITSClusterMap(),
 228                                            pid,
 229                                            vV0FromCascade,
 230                                            kTRUE,  // check if this is right
 231                                            kFALSE, // check if this is right
 232                                            AliAODTrack::kSecondary)
 233                 );
 234         aodTrack->ConvertAliPIDtoAODPID();
 235       }
 236       else {
 237         cerr << "Error: event " << iEvent << " cascade " << nCascade
 238              << " track " << posFromV0 << " has already been used!" << endl;
 239       }
 240
 241       // Add the negative tracks from the V0
 242
 243       if (!usedTrack[negFromV0]) {
 244
 245         usedTrack[negFromV0] = kTRUE;
 246
 247         AliESDtrack *esdTrack = esd->GetTrack(negFromV0);
 248         esdTrack->GetPxPyPz(p);
 249         esdTrack->GetXYZ(pos);
 250         esdTrack->GetCovarianceXYZPxPyPz(covTr);
 251         esdTrack->GetESDpid(pid);
 252
 253         vV0FromCascade->AddDaughter(aodTrack =
 254                 new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
 255                                            esdTrack->GetLabel(),
 256                                            p,
 257                                            kTRUE,
 258                                            pos,
 259                                            kFALSE,
 260                                            covTr,
 261                                            (Short_t)esdTrack->GetSign(),
 262                                            esdTrack->GetITSClusterMap(),
 263                                            pid,
 264                                            vV0FromCascade,
 265                                            kTRUE,  // check if this is right
 266                                            kFALSE, // check if this is right
 267                                            AliAODTrack::kSecondary)
 268                 );
 269         aodTrack->ConvertAliPIDtoAODPID();
 270       }
 271       else {
 272         cerr << "Error: event " << iEvent << " cascade " << nCascade
 273              << " track " << negFromV0 << " has already been used!" << endl;
 274       }
 275
 276       // Add the bachelor track from the cascade
 277
 278       Int_t bachelor = cascade->GetBindex();
 279
 280       if(!usedTrack[bachelor]) {
 281
 282         usedTrack[bachelor] = kTRUE;
 283
 284         AliESDtrack *esdTrack = esd->GetTrack(bachelor);
 285         esdTrack->GetPxPyPz(p);
 286         esdTrack->GetXYZ(pos);
 287         esdTrack->GetCovarianceXYZPxPyPz(covTr);
 288         esdTrack->GetESDpid(pid);
 289
 290         vcascade->AddDaughter(aodTrack =
 291                 new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
 292                                            esdTrack->GetLabel(),
 293                                            p,
 294                                            kTRUE,
 295                                            pos,
 296                                            kFALSE,
 297                                            covTr,
 298                                            (Short_t)esdTrack->GetSign(),
 299                                            esdTrack->GetITSClusterMap(),
 300                                            pid,
 301                                            vcascade,
 302                                            kTRUE,  // check if this is right
 303                                            kFALSE, // check if this is right
 304                                            AliAODTrack::kSecondary)
 305                 );
 306         aodTrack->ConvertAliPIDtoAODPID();
 307      }
 308       else {
 309         cerr << "Error: event " << iEvent << " cascade " << nCascade
 310              << " track " << bachelor << " has already been used!" << endl;
 311       }
 312
 313       // Add the primary track of the cascade (if any)
 314
 315     } // end of the loop on cascades
 316
 317     // V0s
 318
 319     for (Int_t nV0 = 0; nV0 < nV0s; ++nV0) {
 320
 321       if (usedV0[nV0]) continue; // skip if aready added to the AOD
 322
 323       AliESDv0 *v0 = esd->GetV0(nV0);
 324
 325       v0->GetXYZ(pos[0], pos[1], pos[2]);
 326       v0->GetPosCov(covVtx);
 327
 328       AliAODVertex * vV0 =
 329         new(vertices[jVertices++]) AliAODVertex(pos,
 330                                                 covVtx,
 331                                                 v0->GetChi2V0(), // = chi2/NDF since NDF = 2*2-3
 332                                                 primary,
 333                                                 AliAODVertex::kV0);
 334       primary->AddDaughter(vV0);
 335
 336       Int_t posFromV0 = v0->GetPindex();
 337       Int_t negFromV0 = v0->GetNindex();
 338
 339       // Add the positive tracks from the V0
 340
 341       if (!usedTrack[posFromV0]) {
 342
 343         usedTrack[posFromV0] = kTRUE;
 344
 345         AliESDtrack *esdTrack = esd->GetTrack(posFromV0);
 346         esdTrack->GetPxPyPz(p);
 347         esdTrack->GetXYZ(pos);
 348         esdTrack->GetCovarianceXYZPxPyPz(covTr);
 349         esdTrack->GetESDpid(pid);
 350
 351         vV0->AddDaughter(aodTrack =
 352                 new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
 353                                            esdTrack->GetLabel(),
 354                                            p,
 355                                            kTRUE,
 356                                            pos,
 357                                            kFALSE,
 358                                            covTr,
 359                                            (Short_t)esdTrack->GetSign(),
 360                                            esdTrack->GetITSClusterMap(),
 361                                            pid,
 362                                            vV0,
 363                                            kTRUE,  // check if this is right
 364                                            kFALSE, // check if this is right
 365                                            AliAODTrack::kSecondary)
 366                 );
 367         aodTrack->ConvertAliPIDtoAODPID();
 368       }
 369       else {
 370         cerr << "Error: event " << iEvent << " V0 " << nV0
 371              << " track " << posFromV0 << " has already been used!" << endl;
 372       }
 373
 374       // Add the negative tracks from the V0
 375
 376       if (!usedTrack[negFromV0]) {
 377
 378         usedTrack[negFromV0] = kTRUE;
 379
 380         AliESDtrack *esdTrack = esd->GetTrack(negFromV0);
 381         esdTrack->GetPxPyPz(p);
 382         esdTrack->GetXYZ(pos);
 383         esdTrack->GetCovarianceXYZPxPyPz(covTr);
 384         esdTrack->GetESDpid(pid);
 385
 386         vV0->AddDaughter(aodTrack =
 387                 new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
 388                                            esdTrack->GetLabel(),
 389                                            p,
 390                                            kTRUE,
 391                                            pos,
 392                                            kFALSE,
 393                                            covTr,
 394                                            (Short_t)esdTrack->GetSign(),
 395                                            esdTrack->GetITSClusterMap(),
 396                                            pid,
 397                                            vV0,
 398                                            kTRUE,  // check if this is right
 399                                            kFALSE, // check if this is right
 400                                            AliAODTrack::kSecondary)
 401                 );
 402         aodTrack->ConvertAliPIDtoAODPID();
 403       }
 404       else {
 405         cerr << "Error: event " << iEvent << " V0 " << nV0
 406              << " track " << negFromV0 << " has already been used!" << endl;
 407       }
 408
 409     } // end of the loop on V0s
 410
 411     // Kinks: it is a big mess the access to the information in the kinks
 412     // The loop is on the tracks in order to find the mother and daugther of each kink
 413
 414
 415     for (Int_t iTrack=0; iTrack<nTracks; ++iTrack) {
 416
 417
 418       AliESDtrack * esdTrack = esd->GetTrack(iTrack);
 419
 420       Int_t ikink = esdTrack->GetKinkIndex(0);
 421
 422       if (ikink) {
 423         // Negative kink index: mother, positive: daughter
 424
 425         // Search for the second track of the kink
 426
 427         for (Int_t jTrack = iTrack+1; jTrack<nTracks; ++jTrack) {
 428
 429           AliESDtrack * esdTrack1 = esd->GetTrack(jTrack);
 430
 431           Int_t jkink = esdTrack1->GetKinkIndex(0);
 432
 433           if ( TMath::Abs(ikink)==TMath::Abs(jkink) ) {
 434
 435             // The two tracks are from the same kink
 436
 437             if (usedKink[TMath::Abs(ikink)-1]) continue; // skip used kinks
 438
 439             Int_t imother = -1;
 440             Int_t idaughter = -1;
 441
 442             if (ikink<0 && jkink>0) {
 443
 444               imother = iTrack;
 445               idaughter = jTrack;
 446             }
 447             else if (ikink>0 && jkink<0) {
 448
 449               imother = jTrack;
 450               idaughter = iTrack;
 451             }
 452             else {
 453               cerr << "Error: Wrong combination of kink indexes: "
 454               << ikink << " " << jkink << endl;
 455               continue;
 456             }
 457
 458             // Add the mother track
 459
 460             AliAODTrack * mother = NULL;
 461
 462             if (!usedTrack[imother]) {
 463
 464               usedTrack[imother] = kTRUE;
 465
 466               AliESDtrack *esdTrack = esd->GetTrack(imother);
 467               esdTrack->GetPxPyPz(p);
 468               esdTrack->GetXYZ(pos);
 469               esdTrack->GetCovarianceXYZPxPyPz(covTr);
 470               esdTrack->GetESDpid(pid);
 471
 472               mother =
 473                 new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
 474                                            esdTrack->GetLabel(),
 475                                            p,
 476                                            kTRUE,
 477                                            pos,
 478                                            kFALSE,
 479                                            covTr,
 480                                            (Short_t)esdTrack->GetSign(),
 481                                            esdTrack->GetITSClusterMap(),
 482                                            pid,
 483                                            primary,
 484                                            kTRUE, // check if this is right
 485                                            kTRUE, // check if this is right
 486                                            AliAODTrack::kPrimary);
 487               primary->AddDaughter(mother);
 488               mother->ConvertAliPIDtoAODPID();
 489             }
 490             else {
 491               cerr << "Error: event " << iEvent << " kink " << TMath::Abs(ikink)-1
 492               << " track " << imother << " has already been used!" << endl;
 493             }
 494
 495             // Add the kink vertex
 496             AliESDkink * kink = esd->GetKink(TMath::Abs(ikink)-1);
 497
 498             AliAODVertex * vkink =
 499             new(vertices[jVertices++]) AliAODVertex(kink->GetPosition(),
 500                                                     NULL,
 501                                                     0.,
 502                                                     mother,
 503                                                     AliAODVertex::kKink);
 504             // Add the daughter track
 505
 506             AliAODTrack * daughter = NULL;
 507
 508             if (!usedTrack[idaughter]) {
 509
 510               usedTrack[idaughter] = kTRUE;
 511
 512               AliESDtrack *esdTrack = esd->GetTrack(idaughter);
 513               esdTrack->GetPxPyPz(p);
 514               esdTrack->GetXYZ(pos);
 515               esdTrack->GetCovarianceXYZPxPyPz(covTr);
 516               esdTrack->GetESDpid(pid);
 517
 518               daughter =
 519                 new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
 520                                            esdTrack->GetLabel(),
 521                                            p,
 522                                            kTRUE,
 523                                            pos,
 524                                            kFALSE,
 525                                            covTr,
 526                                            (Short_t)esdTrack->GetSign(),
 527                                            esdTrack->GetITSClusterMap(),
 528                                            pid,
 529                                            vkink,
 530                                            kTRUE, // check if this is right
 531                                            kTRUE, // check if this is right
 532                                            AliAODTrack::kPrimary);
 533               vkink->AddDaughter(daughter);
 534               daughter->ConvertAliPIDtoAODPID();
 535             }
 536             else {
 537               cerr << "Error: event " << iEvent << " kink " << TMath::Abs(ikink)-1
 538               << " track " << idaughter << " has already been used!" << endl;
 539             }
 540
 541
 542           }
 543         }
 544
 545       }
 546
 547     }
 548
 549
 550     // Tracks (primary and orphan)
 551
 552     for (Int_t nTrack = 0; nTrack < nTracks; ++nTrack) {
 553
 554
 555       if (usedTrack[nTrack]) continue;
 556
 557       AliESDtrack *esdTrack = esd->GetTrack(nTrack);
 558       esdTrack->GetPxPyPz(p);
 559       esdTrack->GetXYZ(pos);
 560       esdTrack->GetCovarianceXYZPxPyPz(covTr);
 561       esdTrack->GetESDpid(pid);
 562
 563       Float_t impactXY, impactZ;
 564
 565       esdTrack->GetImpactParameters(impactXY,impactZ);
 566
 567       if (impactXY<3) {
 568         // track inside the beam pipe
 569
 570         primary->AddDaughter(aodTrack =
 571             new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
 572                                          esdTrack->GetLabel(),
 573                                          p,
 574                                          kTRUE,
 575                                          pos,
 576                                          kFALSE,
 577                                          covTr,
 578                                          (Short_t)esdTrack->GetSign(),
 579                                          esdTrack->GetITSClusterMap(),
 580                                          pid,
 581                                          primary,
 582                                          kTRUE, // check if this is right
 583                                          kTRUE, // check if this is right
 584                                          AliAODTrack::kPrimary)
 585             );
 586         aodTrack->ConvertAliPIDtoAODPID();
 587       }
 588       else {
 589         // outside the beam pipe: orphan track
 590             aodTrack =
 591             new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
 592                                          esdTrack->GetLabel(),
 593                                          p,
 594                                          kTRUE,
 595                                          pos,
 596                                          kFALSE,
 597                                          covTr,
 598                                          (Short_t)esdTrack->GetSign(),
 599                                          esdTrack->GetITSClusterMap(),
 600                                          pid,
 601                                          NULL,
 602                                          kFALSE, // check if this is right
 603                                          kFALSE, // check if this is right
 604                                          AliAODTrack::kOrphan);
 605             aodTrack->ConvertAliPIDtoAODPID();
 606       }
 607     } // end of loop on tracks
 608
 609     // muon tracks
 610     Int_t nMuTracks = esd->GetNumberOfMuonTracks();
 611     for (Int_t nMuTrack = 0; nMuTrack < nMuTracks; ++nMuTrack) {
 612
 613       AliESDMuonTrack *esdMuTrack = esd->GetMuonTrack(nMuTrack);
 614       p[0] = esdMuTrack->Px();
 615       p[1] = esdMuTrack->Py();
 616       p[2] = esdMuTrack->Pz();
 617       pos[0] = primary->GetX();
 618       pos[1] = primary->GetY();
 619       pos[2] = primary->GetZ();
 620
 621       // has to be changed once the muon pid is provided by the ESD
 622       for (Int_t i = 0; i < 10; pid[i++] = 0.); pid[AliAODTrack::kMuon]=1.;
 623
 624       primary->AddDaughter(
 625           new(tracks[jTracks++]) AliAODTrack(0, // no ID provided
 626                                              0, // no label provided
 627                                              p,
 628                                              kTRUE,
 629                                              pos,
 630                                              kFALSE,
 631                                              NULL, // no covariance matrix provided
 632                                              (Short_t)-99, // no charge provided
 633                                              0, // no ITSClusterMap
 634                                              pid,
 635                                              primary,
 636                                              kTRUE,  // check if this is right
 637                                              kTRUE,  // not used for vertex fit
 638                                              AliAODTrack::kPrimary)
 639           );
 640     }
 641
 642     // Access to the AOD container of clusters
 643     TClonesArray &clusters = *(aod->GetClusters());
 644     Int_t jClusters=0;
 645
 646     // Calo Clusters
 647     Int_t nClusters    = esd->GetNumberOfCaloClusters();
 648
 649     for (Int_t iClust=0; iClust<nClusters; ++iClust) {
 650
 651       AliESDCaloCluster * cluster = esd->GetCaloCluster(iClust);
 652
 653       Int_t id = cluster->GetID();
 654       Int_t label = -1;
 655       Float_t energy = cluster->GetClusterEnergy();
 656       cluster->GetGlobalPosition(posF);
 657       AliAODVertex *prodVertex = primary;
 658       AliAODTrack *primTrack = NULL;
 659       Char_t ttype=AliAODCluster::kUndef;
 660
 661       if (cluster->IsPHOS()) ttype=AliAODCluster::kPHOSNeutral;
 662       else if (cluster->IsEMCAL()) {
 663
 664         if (cluster->GetClusterType() == AliESDCaloCluster::kPseudoCluster)
 665           ttype = AliAODCluster::kEMCALPseudoCluster;
 666         else
 667           ttype = AliAODCluster::kEMCALClusterv1;
 668
 669       }
 670
 671       new(clusters[jClusters++]) AliAODCluster(id,
 672                                                label,
 673                                                energy,
 674                                                pos,
 675                                                NULL, // no covariance matrix provided
 676                                                NULL, // no pid for clusters provided
 677                                                prodVertex,
 678                                                primTrack,
 679                                                ttype);
 680
 681     } // end of loop on calo clusters
 682
 683     delete [] usedTrack;
 684     delete [] usedV0;
 685     delete [] usedKink;
 686
 687     // fill the tree for this event
 688     aodTree->Fill();
 689   } // end of event loop
 690
 691   aodTree->GetUserInfo()->Add(aod);
 692
 693   // close ESD file
 694   inFile->Close();
 695
 696   // write the tree to the specified file
 697   outFile = aodTree->GetCurrentFile();
 698   outFile->cd();
 699   aodTree->Write();
 700   outFile->Close();
 701
 702 }