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