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