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