ANALYSIS/AliAnalysisTaskESDfilter.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   3  *                                                                        *
   4  * Author: The ALICE Off-line Project.                                    *
   5  * Contributors are mentioned in the code where appropriate.              *
   6  *                                                                        *
   7  * Permission to use, copy, modify and distribute this software and its   *
   8  * documentation strictly for non-commercial purposes is hereby granted   *
   9  * without fee, provided that the above copyright notice appears in all   *
  10  * copies and that both the copyright notice and this permission notice   *
  11  * appear in the supporting documentation. The authors make no claims     *
  12  * about the suitability of this software for any purpose. It is          *
  13  * provided "as is" without express or implied warranty.                  *
  14  **************************************************************************/
  15
  16 /* $Id: AliAnalysisTaskESDfilter.cxx 24535 2008-03-16 22:43:30Z fca $ */
  17
  18 #include <TChain.h>
  19 #include <TFile.h>
  20 #include <TArrayI.h>
  21
  22 #include "AliAnalysisTaskESDfilter.h"
  23 #include "AliAnalysisManager.h"
  24 #include "AliESDEvent.h"
  25 #include "AliAODEvent.h"
  26 #include "AliESDInputHandler.h"
  27 #include "AliAODHandler.h"
  28 #include "AliAnalysisFilter.h"
  29 #include "AliESDtrack.h"
  30 #include "AliESDMuonTrack.h"
  31 #include "AliESDVertex.h"
  32 #include "AliESDv0.h"
  33 #include "AliESDkink.h"
  34 #include "AliESDcascade.h"
  35 #include "AliESDPmdTrack.h"
  36 #include "AliESDCaloCluster.h"
  37 #include "AliESDCaloCells.h"
  38 #include "AliMultiplicity.h"
  39 #include "AliLog.h"
  40
  41 ClassImp(AliAnalysisTaskESDfilter)
  42
  43 ////////////////////////////////////////////////////////////////////////
  44
  45 AliAnalysisTaskESDfilter::AliAnalysisTaskESDfilter():
  46     AliAnalysisTaskSE(),
  47     fTrackFilter(0x0),
  48     fKinkFilter(0x0),
  49     fV0Filter(0x0)
  50 {
  51   // Default constructor
  52 }
  53
  54 AliAnalysisTaskESDfilter::AliAnalysisTaskESDfilter(const char* name):
  55     AliAnalysisTaskSE(name),
  56     fTrackFilter(0x0),
  57     fKinkFilter(0x0),
  58     fV0Filter(0x0)
  59 {
  60   // Constructor
  61 }
  62
  63 void AliAnalysisTaskESDfilter::UserCreateOutputObjects()
  64 {
  65 // Create the output container
  66     OutputTree()->GetUserInfo()->Add(fTrackFilter);
  67 }
  68
  69 void AliAnalysisTaskESDfilter::Init()
  70 {
  71     // Initialization
  72     if (fDebug > 1) AliInfo("Init() \n");
  73     // Call configuration file
  74 }
  75
  76
  77 void AliAnalysisTaskESDfilter::UserExec(Option_t */*option*/)
  78 {
  79 // Execute analysis for current event
  80 //
  81
  82   Long64_t ientry = Entry();
  83   if (fDebug > 0) printf("Filter: Analysing event # %5d\n", (Int_t) ientry);
  84
  85   ConvertESDtoAOD();
  86 }
  87
  88 void AliAnalysisTaskESDfilter::ConvertESDtoAOD() {
  89     // ESD Filter analysis task executed for each event
  90     AliESDEvent* esd = dynamic_cast<AliESDEvent*>(InputEvent());
  91     AliESD* old = esd->GetAliESDOld();
  92
  93     // set arrays and pointers
  94     Float_t posF[3];
  95     Double_t pos[3];
  96     Double_t p[3];
  97     Double_t p_pos[3];
  98     Double_t p_neg[3];
  99     Double_t covVtx[6];
 100     Double_t covTr[21];
 101     Double_t pid[10];
 102
 103     for (Int_t i = 0; i < 6; i++)  covVtx[i] = 0.;
 104     for (Int_t i = 0; i < 21; i++) covTr [i] = 0.;
 105
 106
 107   // loop over events and fill them
 108
 109   // Multiplicity information needed by the header (to be revised!)
 110     Int_t nTracks    = esd->GetNumberOfTracks();
 111     Int_t nPosTracks = 0;
 112 //    for (Int_t iTrack = 0; iTrack < nTracks; ++iTrack)
 113 //      if (esd->GetTrack(iTrack)->GetSign()> 0) nPosTracks++;
 114
 115     // Update the header
 116
 117     AliAODHeader* header = AODEvent()->GetHeader();
 118     header->SetRunNumber(esd->GetRunNumber());
 119     if (old) {
 120         header->SetBunchCrossNumber(0);
 121         header->SetOrbitNumber(0);
 122         header->SetPeriodNumber(0);
 123         header->SetEventType(0);
 124         header->SetMuonMagFieldScale(-999.); // FIXME
 125         header->SetCentrality(-999.);        // FIXME
 126     } else {
 127         header->SetBunchCrossNumber(esd->GetBunchCrossNumber());
 128         header->SetOrbitNumber(esd->GetOrbitNumber());
 129         header->SetPeriodNumber(esd->GetPeriodNumber());
 130         header->SetEventType(esd->GetEventType());
 131         header->SetMuonMagFieldScale(-999.); // FIXME
 132         header->SetCentrality(-999.);        // FIXME
 133     }
 134
 135     header->SetTriggerMask(esd->GetTriggerMask());
 136     header->SetTriggerCluster(esd->GetTriggerCluster());
 137     header->SetMagneticField(esd->GetMagneticField());
 138     header->SetZDCN1Energy(esd->GetZDCN1Energy());
 139     header->SetZDCP1Energy(esd->GetZDCP1Energy());
 140     header->SetZDCN2Energy(esd->GetZDCN2Energy());
 141     header->SetZDCP2Energy(esd->GetZDCP2Energy());
 142     header->SetZDCEMEnergy(esd->GetZDCEMEnergy(0),esd->GetZDCEMEnergy(1));
 143 //
 144 //
 145     Int_t nV0s      = esd->GetNumberOfV0s();
 146     Int_t nCascades = esd->GetNumberOfCascades();
 147     Int_t nKinks    = esd->GetNumberOfKinks();
 148     Int_t nVertices = nV0s + 2*nCascades /*could lead to two vertices, one V0 and the Xi */+ nKinks + 1 /* = prim. vtx*/;
 149     Int_t nJets     = 0;
 150     Int_t nCaloClus = esd->GetNumberOfCaloClusters();
 151     Int_t nFmdClus  = 0;
 152     Int_t nPmdClus  = esd->GetNumberOfPmdTracks();
 153
 154     if (fDebug > 0)
 155         printf("   NV0=%d  NCASCADES=%d  NKINKS=%d\n", nV0s, nCascades, nKinks);
 156
 157     AODEvent()->ResetStd(nTracks, nVertices, nV0s+nCascades, nJets, nCaloClus, nFmdClus, nPmdClus);
 158
 159     AliAODTrack *aodTrack = 0x0;
 160
 161     // Array to take into account the tracks already added to the AOD
 162     Bool_t * usedTrack = NULL;
 163     if (nTracks>0) {
 164         usedTrack = new Bool_t[nTracks];
 165         for (Int_t iTrack=0; iTrack<nTracks; ++iTrack) usedTrack[iTrack]=kFALSE;
 166     }
 167     // Array to take into account the V0s already added to the AOD
 168     Bool_t * usedV0 = NULL;
 169     if (nV0s>0) {
 170         usedV0 = new Bool_t[nV0s];
 171         for (Int_t iV0=0; iV0<nV0s; ++iV0) usedV0[iV0]=kFALSE;
 172     }
 173     // Array to take into account the kinks already added to the AOD
 174     Bool_t * usedKink = NULL;
 175     if (nKinks>0) {
 176         usedKink = new Bool_t[nKinks];
 177         for (Int_t iKink=0; iKink<nKinks; ++iKink) usedKink[iKink]=kFALSE;
 178     }
 179
 180     // Access to the AOD container of vertices
 181     TClonesArray &vertices = *(AODEvent()->GetVertices());
 182     Int_t jVertices=0;
 183
 184     // Access to the AOD container of tracks
 185     TClonesArray &tracks = *(AODEvent()->GetTracks());
 186     Int_t jTracks=0;
 187
 188     // Access to the AOD container of V0s
 189     TClonesArray &V0s = *(AODEvent()->GetV0s());
 190     Int_t jV0s=0;
 191
 192     // Add primary vertex. The primary tracks will be defined
 193     // after the loops on the composite objects (V0, cascades, kinks)
 194     const AliESDVertex *vtx = esd->GetPrimaryVertex();
 195
 196     vtx->GetXYZ(pos); // position
 197     vtx->GetCovMatrix(covVtx); //covariance matrix
 198
 199     AliAODVertex * primary = new(vertices[jVertices++])
 200         AliAODVertex(pos, covVtx, vtx->GetChi2toNDF(), NULL, AliAODVertex::kPrimary);
 201     if (fDebug > 0) primary->Print();
 202
 203     // Create vertices starting from the most complex objects
 204     Double_t chi2 = 0.;
 205
 206     // Cascades
 207     for (Int_t nCascade = 0; nCascade < nCascades; ++nCascade) {
 208         AliESDcascade *cascade = esd->GetCascade(nCascade);
 209
 210         cascade->GetXYZ(pos[0], pos[1], pos[2]);
 211
 212         if (!old) {
 213             chi2 = cascade->GetChi2Xi(); // = chi2/NDF since NDF = 2*2-3
 214             cascade->GetPosCovXi(covVtx);
 215         } else {
 216             chi2 = -999.;
 217             for (Int_t i = 0; i < 6; i++)  covVtx[i] = 0.;
 218         }
 219         // Add the cascade vertex
 220         AliAODVertex * vcascade = new(vertices[jVertices++]) AliAODVertex(pos,
 221                                                                           covVtx,
 222                                                                           chi2,
 223                                                                           primary,
 224                                                                           nCascade,
 225                                                                           AliAODVertex::kCascade);
 226
 227         primary->AddDaughter(vcascade);
 228
 229         // Add the V0 from the cascade. The ESD class have to be optimized...
 230         // Now we have to search for the corresponding Vo in the list of V0s
 231         // using the indeces of the positive and negative tracks
 232
 233         Int_t posFromV0 = cascade->GetPindex();
 234         Int_t negFromV0 = cascade->GetNindex();
 235
 236
 237         AliESDv0 * v0 = 0x0;
 238         Int_t indV0 = -1;
 239
 240         for (Int_t iV0=0; iV0<nV0s; ++iV0) {
 241
 242             v0 = esd->GetV0(iV0);
 243             Int_t posV0 = v0->GetPindex();
 244             Int_t negV0 = v0->GetNindex();
 245
 246             if (posV0==posFromV0 && negV0==negFromV0) {
 247                 indV0 = iV0;
 248                 break;
 249             }
 250         }
 251
 252         AliAODVertex * vV0FromCascade = 0x0;
 253
 254         if (indV0>-1 && !usedV0[indV0] ) {
 255
 256             // the V0 exists in the array of V0s and is not used
 257
 258             usedV0[indV0] = kTRUE;
 259
 260             v0->GetXYZ(pos[0], pos[1], pos[2]);
 261             if (!old) {
 262                 chi2 = v0->GetChi2V0();  // = chi2/NDF since NDF = 2*2-3
 263                 v0->GetPosCov(covVtx);
 264             } else {
 265                 chi2 = -999.;
 266                 for (Int_t i = 0; i < 6; i++)  covVtx[i] = 0.;
 267             }
 268
 269             vV0FromCascade = new(vertices[jVertices++]) AliAODVertex(pos,
 270                                                                      covVtx,
 271                                                                      chi2,
 272                                                                      vcascade,
 273                                                                      indV0,
 274                                                                      AliAODVertex::kV0);
 275         } else {
 276
 277             // the V0 doesn't exist in the array of V0s or was used
 278 //          cerr << "Error: event " << esd->GetEventNumberInFile() << " cascade " << nCascade
 279 //               << " The V0 " << indV0
 280 //               << " doesn't exist in the array of V0s or was used!" << endl;
 281
 282             cascade->GetXYZ(pos[0], pos[1], pos[2]);
 283
 284             if (!old) {
 285                 chi2 = v0->GetChi2V0();
 286                 cascade->GetPosCov(covVtx);
 287             } else {
 288                 chi2 = -999.;
 289                 for (Int_t i = 0; i < 6; i++)  covVtx[i] = 0.;
 290             }
 291
 292             vV0FromCascade = new(vertices[jVertices++]) AliAODVertex(pos,
 293                                                                      covVtx,
 294                                                                      chi2, // = chi2/NDF since NDF = 2*2-3 (AM)
 295                                                                      vcascade,
 296                                                                      indV0,
 297                                                                      AliAODVertex::kV0);
 298             vcascade->AddDaughter(vV0FromCascade);
 299         }
 300
 301         // Add the positive tracks from the V0
 302
 303         if (posFromV0>-1 && !usedTrack[posFromV0]) {
 304
 305             usedTrack[posFromV0] = kTRUE;
 306
 307             AliESDtrack *esdTrack = esd->GetTrack(posFromV0);
 308             esdTrack->GetPxPyPz(p_pos);
 309             esdTrack->GetXYZ(pos);
 310             esdTrack->GetCovarianceXYZPxPyPz(covTr);
 311             esdTrack->GetESDpid(pid);
 312
 313             vV0FromCascade->AddDaughter(aodTrack =
 314                                         new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
 315                                                                            esdTrack->GetLabel(),
 316                                                                            p_pos,
 317                                                                            kTRUE,
 318                                                                            pos,
 319                                                                            kFALSE,
 320                                                                            covTr,
 321                                                                            (Short_t)esdTrack->GetSign(),
 322                                                                            esdTrack->GetITSClusterMap(),
 323                                                                            pid,
 324                                                                            vV0FromCascade,
 325                                                                            kTRUE,  // check if this is right
 326                                                                            kFALSE, // check if this is right
 327                                                                            AliAODTrack::kSecondary)
 328                 );
 329        if (esdTrack->GetSign() > 0) nPosTracks++;
 330             aodTrack->ConvertAliPIDtoAODPID();
 331             aodTrack->SetFlags(esdTrack->GetStatus());
 332         }
 333         else {
 334 //          cerr << "Error: event " << esd->GetEventNumberInFile() << " cascade " << nCascade
 335 //               << " track " << posFromV0 << " has already been used!" << endl;
 336         }
 337
 338         // Add the negative tracks from the V0
 339
 340         if (negFromV0>-1 && !usedTrack[negFromV0]) {
 341
 342             usedTrack[negFromV0] = kTRUE;
 343
 344             AliESDtrack *esdTrack = esd->GetTrack(negFromV0);
 345             esdTrack->GetPxPyPz(p_neg);
 346             esdTrack->GetXYZ(pos);
 347             esdTrack->GetCovarianceXYZPxPyPz(covTr);
 348             esdTrack->GetESDpid(pid);
 349
 350             vV0FromCascade->AddDaughter(aodTrack =
 351                                         new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
 352                                                                            esdTrack->GetLabel(),
 353                                                                            p_neg,
 354                                                                            kTRUE,
 355                                                                            pos,
 356                                                                            kFALSE,
 357                                                                            covTr,
 358                                                                            (Short_t)esdTrack->GetSign(),
 359                                                                            esdTrack->GetITSClusterMap(),
 360                                                                            pid,
 361                                                                            vV0FromCascade,
 362                                                                            kTRUE,  // check if this is right
 363                                                                            kFALSE, // check if this is right
 364                                                                            AliAODTrack::kSecondary)
 365                 );
 366        if (esdTrack->GetSign() > 0) nPosTracks++;
 367             aodTrack->ConvertAliPIDtoAODPID();
 368             aodTrack->SetFlags(esdTrack->GetStatus());
 369         }
 370         else {
 371 //          cerr << "Error: event " << esd->GetEventNumberInFile() << " cascade " << nCascade
 372 //               << " track " << negFromV0 << " has already been used!" << endl;
 373         }
 374
 375         // add it to the V0 array as well
 376         Double_t d0[2] = { -999., -99.};
 377         // counting is probably wrong
 378         new(V0s[jV0s++]) AliAODv0(vV0FromCascade, -999., -99., p_pos, p_neg, d0); // to be refined
 379
 380         // Add the bachelor track from the cascade
 381
 382         Int_t bachelor = cascade->GetBindex();
 383
 384         if(bachelor>-1 && !usedTrack[bachelor]) {
 385
 386             usedTrack[bachelor] = kTRUE;
 387
 388             AliESDtrack *esdTrack = esd->GetTrack(bachelor);
 389             esdTrack->GetPxPyPz(p);
 390             esdTrack->GetXYZ(pos);
 391             esdTrack->GetCovarianceXYZPxPyPz(covTr);
 392             esdTrack->GetESDpid(pid);
 393
 394             vcascade->AddDaughter(aodTrack =
 395                                   new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
 396                                                                      esdTrack->GetLabel(),
 397                                                                      p,
 398                                                                      kTRUE,
 399                                                                      pos,
 400                                                                      kFALSE,
 401                                                                      covTr,
 402                                                                      (Short_t)esdTrack->GetSign(),
 403                                                                      esdTrack->GetITSClusterMap(),
 404                                                                      pid,
 405                                                                      vcascade,
 406                                                                      kTRUE,  // check if this is right
 407                                                                      kFALSE, // check if this is right
 408                                                                      AliAODTrack::kSecondary)
 409                 );
 410        if (esdTrack->GetSign() > 0) nPosTracks++;
 411             aodTrack->ConvertAliPIDtoAODPID();
 412             aodTrack->SetFlags(esdTrack->GetStatus());
 413         }
 414         else {
 415 //          cerr << "Error: event " << esd->GetEventNumberInFile() << " cascade " << nCascade
 416 //               << " track " << bachelor << " has already been used!" << endl;
 417         }
 418
 419         // Add the primary track of the cascade (if any)
 420
 421     } // end of the loop on cascades
 422
 423     // V0s
 424
 425     for (Int_t nV0 = 0; nV0 < nV0s; ++nV0) {
 426
 427         if (usedV0[nV0]) continue; // skip if aready added to the AOD
 428
 429         AliESDv0 *v0 = esd->GetV0(nV0);
 430
 431         v0->GetXYZ(pos[0], pos[1], pos[2]);
 432
 433         if (!old) {
 434             chi2 = v0->GetChi2V0(); // = chi2/NDF since NDF = 2*2-3
 435             v0->GetPosCov(covVtx);
 436         } else {
 437             chi2 = -999.;
 438             for (Int_t i = 0; i < 6; i++)  covVtx[i] = 0.;
 439         }
 440
 441
 442         AliAODVertex * vV0 =
 443           new(vertices[jVertices++]) AliAODVertex(pos,
 444                                                   covVtx,
 445                                                   chi2,
 446                                                   primary,
 447                                                   nV0,
 448                                                   AliAODVertex::kV0);
 449         primary->AddDaughter(vV0);
 450
 451         Int_t posFromV0 = v0->GetPindex();
 452         Int_t negFromV0 = v0->GetNindex();
 453
 454         // Add the positive tracks from the V0
 455
 456         if (posFromV0>-1 && !usedTrack[posFromV0]) {
 457
 458             usedTrack[posFromV0] = kTRUE;
 459
 460             AliESDtrack *esdTrack = esd->GetTrack(posFromV0);
 461             esdTrack->GetPxPyPz(p_pos);
 462             esdTrack->GetXYZ(pos);
 463             esdTrack->GetCovarianceXYZPxPyPz(covTr);
 464             esdTrack->GetESDpid(pid);
 465
 466             vV0->AddDaughter(aodTrack =
 467                              new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
 468                                                                 esdTrack->GetLabel(),
 469                                                                 p_pos,
 470                                                                 kTRUE,
 471                                                                 pos,
 472                                                                 kFALSE,
 473                                                                 covTr,
 474                                                                 (Short_t)esdTrack->GetSign(),
 475                                                                 esdTrack->GetITSClusterMap(),
 476                                                                 pid,
 477                                                                 vV0,
 478                                                                 kTRUE,  // check if this is right
 479                                                                 kFALSE, // check if this is right
 480                                                                 AliAODTrack::kSecondary)
 481                 );
 482        if (esdTrack->GetSign() > 0) nPosTracks++;
 483             aodTrack->ConvertAliPIDtoAODPID();
 484             aodTrack->SetFlags(esdTrack->GetStatus());
 485         }
 486         else {
 487 //          cerr << "Error: event " << esd->GetEventNumberInFile() << " V0 " << nV0
 488 //               << " track " << posFromV0 << " has already been used!" << endl;
 489         }
 490
 491         // Add the negative tracks from the V0
 492
 493         if (negFromV0>-1 && !usedTrack[negFromV0]) {
 494
 495             usedTrack[negFromV0] = kTRUE;
 496
 497             AliESDtrack *esdTrack = esd->GetTrack(negFromV0);
 498             esdTrack->GetPxPyPz(p_neg);
 499             esdTrack->GetXYZ(pos);
 500             esdTrack->GetCovarianceXYZPxPyPz(covTr);
 501             esdTrack->GetESDpid(pid);
 502
 503             vV0->AddDaughter(aodTrack =
 504                              new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
 505                                                                 esdTrack->GetLabel(),
 506                                                                 p_neg,
 507                                                                 kTRUE,
 508                                                                 pos,
 509                                                                 kFALSE,
 510                                                                 covTr,
 511                                                                 (Short_t)esdTrack->GetSign(),
 512                                                                 esdTrack->GetITSClusterMap(),
 513                                                                 pid,
 514                                                                 vV0,
 515                                                                 kTRUE,  // check if this is right
 516                                                                 kFALSE, // check if this is right
 517                                                                 AliAODTrack::kSecondary)
 518                 );
 519        if (esdTrack->GetSign() > 0) nPosTracks++;
 520             aodTrack->ConvertAliPIDtoAODPID();
 521             aodTrack->SetFlags(esdTrack->GetStatus());
 522         }
 523         else {
 524 //          cerr << "Error: event " << esd->GetEventNumberInFile() << " V0 " << nV0
 525 //               << " track " << negFromV0 << " has already been used!" << endl;
 526         }
 527
 528         // add it to the V0 array as well
 529         Double_t d0[2] = { 999., 99.};
 530         new(V0s[jV0s++]) AliAODv0(vV0, 999., 99., p_pos, p_neg, d0); // to be refined
 531     }
 532     V0s.Expand(jV0s);
 533     // end of the loop on V0s
 534
 535     // Kinks: it is a big mess the access to the information in the kinks
 536     // The loop is on the tracks in order to find the mother and daugther of each kink
 537
 538
 539     for (Int_t iTrack=0; iTrack<nTracks; ++iTrack) {
 540
 541         AliESDtrack * esdTrack = esd->GetTrack(iTrack);
 542
 543         Int_t ikink = esdTrack->GetKinkIndex(0);
 544
 545         if (ikink && nKinks) {
 546             // Negative kink index: mother, positive: daughter
 547
 548             // Search for the second track of the kink
 549
 550             for (Int_t jTrack = iTrack+1; jTrack<nTracks; ++jTrack) {
 551
 552                 AliESDtrack * esdTrack1 = esd->GetTrack(jTrack);
 553
 554                 Int_t jkink = esdTrack1->GetKinkIndex(0);
 555
 556                 if ( TMath::Abs(ikink)==TMath::Abs(jkink) ) {
 557
 558                     // The two tracks are from the same kink
 559
 560                     if (usedKink[TMath::Abs(ikink)-1]) continue; // skip used kinks
 561
 562                     Int_t imother = -1;
 563                     Int_t idaughter = -1;
 564
 565                     if (ikink<0 && jkink>0) {
 566
 567                         imother = iTrack;
 568                         idaughter = jTrack;
 569                     }
 570                     else if (ikink>0 && jkink<0) {
 571
 572                         imother = jTrack;
 573                         idaughter = iTrack;
 574                     }
 575                     else {
 576 //                      cerr << "Error: Wrong combination of kink indexes: "
 577 //                           << ikink << " " << jkink << endl;
 578                         continue;
 579                     }
 580
 581                     // Add the mother track
 582
 583                     AliAODTrack * mother = NULL;
 584
 585                     if (!usedTrack[imother]) {
 586
 587                         usedTrack[imother] = kTRUE;
 588
 589                         AliESDtrack *esdTrackM = esd->GetTrack(imother);
 590                         esdTrackM->GetPxPyPz(p);
 591                         esdTrackM->GetXYZ(pos);
 592                         esdTrackM->GetCovarianceXYZPxPyPz(covTr);
 593                         esdTrackM->GetESDpid(pid);
 594
 595                         mother =
 596                             new(tracks[jTracks++]) AliAODTrack(esdTrackM->GetID(),
 597                                                                esdTrackM->GetLabel(),
 598                                                                p,
 599                                                                kTRUE,
 600                                                                pos,
 601                                                                kFALSE,
 602                                                                covTr,
 603                                                                (Short_t)esdTrackM->GetSign(),
 604                                                                esdTrackM->GetITSClusterMap(),
 605                                                                pid,
 606                                                                primary,
 607                                                                kTRUE, // check if this is right
 608                                                                kTRUE, // check if this is right
 609                                                                AliAODTrack::kPrimary);
 610                         if (esdTrackM->GetSign() > 0) nPosTracks++;
 611                         mother->SetFlags(esdTrackM->GetStatus());
 612                         mother->ConvertAliPIDtoAODPID();
 613                         primary->AddDaughter(mother);
 614                         mother->ConvertAliPIDtoAODPID();
 615                     }
 616                     else {
 617 //                      cerr << "Error: event " << esd->GetEventNumberInFile() << " kink " << TMath::Abs(ikink)-1
 618 //                           << " track " << imother << " has already been used!" << endl;
 619                   }
 620
 621                     // Add the kink vertex
 622                     AliESDkink * kink = esd->GetKink(TMath::Abs(ikink)-1);
 623
 624                     AliAODVertex * vkink =
 625                         new(vertices[jVertices++]) AliAODVertex(kink->GetPosition(),
 626                                                                 NULL,
 627                                                                 0.,
 628                                                                 mother,
 629                                                                 esdTrack->GetID(),  // This is the track ID of the mother's track!
 630                                                                 AliAODVertex::kKink);
 631                     // Add the daughter track
 632
 633                     AliAODTrack * daughter = NULL;
 634
 635                     if (!usedTrack[idaughter]) {
 636
 637                         usedTrack[idaughter] = kTRUE;
 638
 639                         AliESDtrack *esdTrackD = esd->GetTrack(idaughter);
 640                         esdTrackD->GetPxPyPz(p);
 641                         esdTrackD->GetXYZ(pos);
 642                         esdTrackD->GetCovarianceXYZPxPyPz(covTr);
 643                         esdTrackD->GetESDpid(pid);
 644
 645                         daughter =
 646                             new(tracks[jTracks++]) AliAODTrack(esdTrackD->GetID(),
 647                                                                esdTrackD->GetLabel(),
 648                                                                p,
 649                                                                kTRUE,
 650                                                                pos,
 651                                                                kFALSE,
 652                                                                covTr,
 653                                                                (Short_t)esdTrackD->GetSign(),
 654                                                                esdTrackD->GetITSClusterMap(),
 655                                                                pid,
 656                                                                vkink,
 657                                                                kTRUE, // check if this is right
 658                                                                kTRUE, // check if this is right
 659                                                                AliAODTrack::kPrimary);
 660                         if (esdTrackD->GetSign() > 0) nPosTracks++;
 661                         daughter->SetFlags(esdTrackD->GetStatus());
 662                         daughter->ConvertAliPIDtoAODPID();
 663                         vkink->AddDaughter(daughter);
 664                         daughter->ConvertAliPIDtoAODPID();
 665                     }
 666                     else {
 667 //                      cerr << "Error: event " << esd->GetEventNumberInFile() << " kink " << TMath::Abs(ikink)-1
 668 //                           << " track " << idaughter << " has already been used!" << endl;
 669                     }
 670                 }
 671             }
 672         }
 673     }
 674
 675
 676     // Tracks (primary and orphan)
 677
 678     if (fDebug > 0) printf("NUMBER OF ESD TRACKS %5d\n", nTracks);
 679
 680     for (Int_t nTrack = 0; nTrack < nTracks; ++nTrack) {
 681
 682
 683         if (usedTrack[nTrack]) continue;
 684
 685         AliESDtrack *esdTrack = esd->GetTrack(nTrack);
 686         UInt_t selectInfo = 0;
 687         //
 688         // Track selection
 689         if (fTrackFilter) {
 690             selectInfo = fTrackFilter->IsSelected(esdTrack);
 691             if (!selectInfo) continue;
 692         }
 693
 694         //
 695         esdTrack->GetPxPyPz(p);
 696         esdTrack->GetXYZ(pos);
 697         esdTrack->GetCovarianceXYZPxPyPz(covTr);
 698         esdTrack->GetESDpid(pid);
 699
 700         Float_t impactXY, impactZ;
 701
 702         esdTrack->GetImpactParameters(impactXY,impactZ);
 703
 704         if (impactXY<3) {
 705             // track inside the beam pipe
 706
 707             primary->AddDaughter(aodTrack =
 708                                  new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
 709                                                                     esdTrack->GetLabel(),
 710                                                                     p,
 711                                                                     kTRUE,
 712                                                                     pos,
 713                                                                     kFALSE,
 714                                                                     covTr,
 715                                                                     (Short_t)esdTrack->GetSign(),
 716                                                                     esdTrack->GetITSClusterMap(),
 717                                                                     pid,
 718                                                                     primary,
 719                                                                     kTRUE, // check if this is right
 720                                                                     kTRUE, // check if this is right
 721                                                                     AliAODTrack::kPrimary,
 722                                                                     selectInfo)
 723                 );
 724        if (esdTrack->GetSign() > 0) nPosTracks++;
 725             aodTrack->SetFlags(esdTrack->GetStatus());
 726             aodTrack->ConvertAliPIDtoAODPID();
 727         }
 728         else {
 729           // outside the beam pipe: orphan track
 730           // Don't write them anymore!
 731           continue;
 732           /*
 733           aodTrack =
 734             new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
 735                                                esdTrack->GetLabel(),
 736                                                p,
 737                                                kTRUE,
 738                                                pos,
 739                                                kFALSE,
 740                                                covTr,
 741                                                (Short_t)esdTrack->GetSign(),
 742                                                esdTrack->GetITSClusterMap(),
 743                                                pid,
 744                                                NULL,
 745                                                kFALSE, // check if this is right
 746                                                kFALSE, // check if this is right
 747                                                AliAODTrack::kOrphan,
 748                                                selectInfo);
 749      if (esdTrack->GetSign() > 0) nPosTracks++;
 750           aodTrack->SetFlags(esdTrack->GetStatus());
 751           aodTrack->ConvertAliPIDtoAODPID();
 752           */
 753         }
 754     } // end of loop on tracks
 755
 756     // Update number of AOD tracks in header at the end of track loop (M.G.)
 757     header->SetRefMultiplicity(jTracks);
 758     header->SetRefMultiplicityPos(nPosTracks);
 759     header->SetRefMultiplicityNeg(jTracks - nPosTracks);
 760     if (fDebug > 0)
 761       printf("   NAODTRACKS=%d  NPOS=%d  NNEG=%d\n", jTracks, nPosTracks, jTracks - nPosTracks);
 762     // Do not shrink the array of tracks - other filters may add to it (M.G)
 763 //    tracks.Expand(jTracks); // remove 'empty slots' due to unwritten tracks
 764
 765     // Access to the AOD container of PMD clusters
 766     TClonesArray &pmdClusters = *(AODEvent()->GetPmdClusters());
 767     Int_t jPmdClusters=0;
 768
 769     for (Int_t iPmd = 0; iPmd < nPmdClus; ++iPmd) {
 770       // file pmd clusters, to be revised!
 771       AliESDPmdTrack *pmdTrack = esd->GetPmdTrack(iPmd);
 772       Int_t nLabel = 0;
 773       Int_t *label = 0x0;
 774       Double_t posPmd[3] = { pmdTrack->GetClusterX(), pmdTrack->GetClusterY(), pmdTrack->GetClusterZ()};
 775       Double_t pidPmd[9] = { 0., 0., 0., 0., 0., 0., 0., 0., 0. }; // to be revised!
 776       // type not set!
 777       // assoc cluster not set
 778       new(pmdClusters[jPmdClusters++]) AliAODPmdCluster(iPmd, nLabel, label, pmdTrack->GetClusterADC(), posPmd, pidPmd);
 779     }
 780
 781     // Access to the AOD container of clusters
 782     TClonesArray &caloClusters = *(AODEvent()->GetCaloClusters());
 783     Int_t jClusters=0;
 784
 785     for (Int_t iClust=0; iClust<nCaloClus; ++iClust) {
 786
 787       AliESDCaloCluster * cluster = esd->GetCaloCluster(iClust);
 788
 789       Int_t id        = cluster->GetID();
 790       Int_t nLabel    = cluster->GetNLabels();
 791       TArrayI* labels = cluster->GetLabels();
 792       Int_t *label = 0;
 793       if (labels) label = (cluster->GetLabels())->GetArray();
 794
 795       Float_t energy = cluster->E();
 796       cluster->GetPosition(posF);
 797       Char_t ttype = AliAODCluster::kUndef;
 798
 799       if (cluster->GetClusterType() == AliESDCaloCluster::kPHOSCluster) {
 800         ttype=AliAODCluster::kPHOSNeutral;
 801       }
 802       else if (cluster->GetClusterType() == AliESDCaloCluster::kEMCALClusterv1) {
 803         ttype = AliAODCluster::kEMCALClusterv1;
 804       }
 805
 806
 807       AliAODCaloCluster *caloCluster = new(caloClusters[jClusters++]) AliAODCaloCluster(id,
 808                                                                                         nLabel,
 809                                                                                         label,
 810                                                                                         energy,
 811                                                                                         pos,
 812                                                                                         NULL,
 813                                                                                         ttype);
 814
 815       caloCluster->SetCaloCluster(cluster->GetDistanceToBadChannel(),
 816                                   cluster->GetClusterDisp(),
 817                                   cluster->GetM20(), cluster->GetM02(),
 818                                   cluster->GetEmcCpvDistance(),
 819                                   cluster->GetNExMax(),cluster->GetTOF()) ;
 820
 821       caloCluster->SetPIDFromESD(cluster->GetPid());
 822       caloCluster->SetNCells(cluster->GetNCells());
 823       caloCluster->SetCellsAbsId(cluster->GetCellsAbsId());
 824       caloCluster->SetCellsAmplitudeFraction(cluster->GetCellsAmplitudeFraction());
 825
 826       TArrayI* matchedT =       cluster->GetTracksMatched();
 827       if (matchedT) {
 828         for (Int_t im = 0; im < matchedT->GetSize(); im++) {
 829           caloCluster->AddTrackMatched((esd->GetTrack(im)));
 830         }
 831       }
 832
 833     }
 834     caloClusters.Expand(jClusters); // resize TObjArray to 'remove' slots for pseudo clusters
 835     // end of loop on calo clusters
 836
 837     // fill EMCAL cell info
 838     if (esd->GetEMCALCells()) { // protection against missing ESD information
 839       AliESDCaloCells &esdEMcells = *(esd->GetEMCALCells());
 840       Int_t nEMcell = esdEMcells.GetNumberOfCells() ;
 841
 842       AliAODCaloCells &aodEMcells = *(AODEvent()->GetEMCALCells());
 843       aodEMcells.CreateContainer(nEMcell);
 844       aodEMcells.SetType(AliAODCaloCells::kEMCAL);
 845       for (Int_t iCell = 0; iCell < nEMcell; iCell++) {
 846         aodEMcells.SetCell(iCell,esdEMcells.GetCellNumber(iCell),esdEMcells.GetAmplitude(iCell));
 847       }
 848       aodEMcells.Sort();
 849     }
 850
 851     // fill PHOS cell info
 852     if (esd->GetPHOSCells()) { // protection against missing ESD information
 853       AliESDCaloCells &esdPHcells = *(esd->GetPHOSCells());
 854       Int_t nPHcell = esdPHcells.GetNumberOfCells() ;
 855
 856       AliAODCaloCells &aodPHcells = *(AODEvent()->GetPHOSCells());
 857       aodPHcells.CreateContainer(nPHcell);
 858       aodPHcells.SetType(AliAODCaloCells::kPHOS);
 859       for (Int_t iCell = 0; iCell < nPHcell; iCell++) {
 860         aodPHcells.SetCell(iCell,esdPHcells.GetCellNumber(iCell),esdPHcells.GetAmplitude(iCell));
 861       }
 862       aodPHcells.Sort();
 863     }
 864
 865     // tracklets
 866     AliAODTracklets &SPDTracklets = *(AODEvent()->GetTracklets());
 867     const AliMultiplicity *mult = esd->GetMultiplicity();
 868     if (mult) {
 869       if (mult->GetNumberOfTracklets()>0) {
 870         SPDTracklets.CreateContainer(mult->GetNumberOfTracklets());
 871
 872         for (Int_t n=0; n<mult->GetNumberOfTracklets(); n++) {
 873           SPDTracklets.SetTracklet(n, mult->GetTheta(n), mult->GetPhi(n), mult->GetDeltaPhi(n), mult->GetLabel(n, 0), mult->GetLabel(n, 1));
 874         }
 875       }
 876     } else {
 877       //Printf("ERROR: AliMultiplicity could not be retrieved from ESD");
 878     }
 879
 880     delete [] usedTrack;
 881     delete [] usedV0;
 882     delete [] usedKink;
 883
 884     return;
 885 }
 886
 887 void AliAnalysisTaskESDfilter::Terminate(Option_t */*option*/)
 888 {
 889 // Terminate analysis
 890 //
 891     if (fDebug > 1) printf("AnalysisESDfilter: Terminate() \n");
 892 }
 893