PWG2/AOD/AliAnalysisTaskPWG2ESDfilter.cxx

   1 //-------------------------------------------------------------------------
   2 //     Task for the Analysis Framework
   3 // Creates a PWG2 specific AOD, from the ESD adding information required
   4 // for PWG2 analysis.
   5 //  - Puts the per-track information into the AliPWG2AODTrack container,
   6 //    together with the link to the original AliAODTrack
   7 //
   8 //     Author: Adam Kisiel, OSU, Adam.Kisiel@cern.ch
   9 //-------------------------------------------------------------------------
  10 #include <TChain.h>
  11 #include <TFile.h>
  12 #include <TList.h>
  13
  14 #include "AliAnalysisTaskPWG2ESDfilter.h"
  15 #include "AliAnalysisManager.h"
  16 #include "AliESDEvent.h"
  17 #include "AliAODEvent.h"
  18 #include "AliESDInputHandler.h"
  19 #include "AliAODHandler.h"
  20 #include "AliAnalysisFilter.h"
  21 #include "AliESDtrack.h"
  22 #include "AliESDMuonTrack.h"
  23 #include "AliESDVertex.h"
  24 #include "AliESDv0.h"
  25 #include "AliESDkink.h"
  26 #include "AliESDcascade.h"
  27 #include "AliLog.h"
  28 #include "AliPWG2AODTrack.h"
  29
  30 ClassImp(AliAnalysisTaskPWG2ESDfilter)
  31
  32 ////////////////////////////////////////////////////////////////////////
  33
  34 AliAnalysisTaskPWG2ESDfilter::AliAnalysisTaskPWG2ESDfilter():
  35     fDebug(0),
  36     fTree(0x0),
  37     fESD(0x0),
  38     fAOD(0x0),
  39     fTreeA(0x0),
  40     fTrackFilter(0x0),
  41     fKinkFilter(0x0),
  42     fV0Filter(0x0),
  43     fPWG2AODTracks(0x0)
  44 {
  45   // Default constructor
  46 }
  47
  48 AliAnalysisTaskPWG2ESDfilter::AliAnalysisTaskPWG2ESDfilter(const char* name):
  49     AliAnalysisTask(name, "AnalysisTaskESDfilter"),
  50     fDebug(0),
  51     fTree(0x0),
  52     fESD(0x0),
  53     fAOD(0x0),
  54     fTreeA(0x0),
  55     fTrackFilter(0x0),
  56     fKinkFilter(0x0),
  57     fV0Filter(0x0),
  58     fPWG2AODTracks(0x0)
  59 {
  60   // Default constructor
  61     DefineInput (0, TChain::Class());
  62     DefineOutput(0, TTree::Class());
  63 }
  64
  65 AliAnalysisTaskPWG2ESDfilter::AliAnalysisTaskPWG2ESDfilter(const AliAnalysisTaskPWG2ESDfilter &task):
  66   AliAnalysisTask(),
  67   fDebug(0),
  68   fTree(0x0),
  69   fESD(0x0),
  70   fAOD(0x0),
  71   fTreeA(0x0),
  72   fTrackFilter(0x0),
  73   fKinkFilter(0x0),
  74   fV0Filter(0x0),
  75   fPWG2AODTracks(0x0)
  76 {
  77   // Copy
  78   fDebug = task.fDebug;
  79   fTree = task.fTree;
  80   fESD = task.fESD;
  81   fAOD =  task.fAOD;
  82   fTreeA = task.fTreeA;
  83   fTrackFilter = task.fTrackFilter;
  84   fKinkFilter = task.fKinkFilter;
  85   fV0Filter = task.fV0Filter;
  86   fPWG2AODTracks = task.fPWG2AODTracks;
  87 }
  88
  89 AliAnalysisTaskPWG2ESDfilter& AliAnalysisTaskPWG2ESDfilter::operator=(const AliAnalysisTaskPWG2ESDfilter &task)
  90 {
  91   // Assignment
  92   if (&task == this) return *this;
  93   TTask::operator=(task);
  94
  95   fDebug = task.fDebug;
  96   fTree = task.fTree;
  97   fESD = task.fESD;
  98   fAOD =  task.fAOD;
  99   fTreeA = task.fTreeA;
 100   fTrackFilter = task.fTrackFilter;
 101   fKinkFilter = task.fKinkFilter;
 102   fV0Filter = task.fV0Filter;
 103   fPWG2AODTracks = task.fPWG2AODTracks;
 104
 105   return *this;
 106 }
 107
 108 void AliAnalysisTaskPWG2ESDfilter::CreateOutputObjects()
 109 {
 110 // Create the output container
 111     if (fDebug > 1) AliInfo("CreateOutPutData() \n");
 112     AliAODHandler* handler = (AliAODHandler*) ((AliAnalysisManager::GetAnalysisManager())->GetOutputEventHandler());
 113
 114     fAOD   = handler->GetAOD();
 115     fTreeA = handler->GetTree();
 116     fTreeA->GetUserInfo()->Add(fTrackFilter);
 117
 118     // *** PWG2 specific ***
 119
 120     fPWG2AODTracks = new TClonesArray("AliPWG2AODTrack", 0);
 121     const char *name = "pwg2aodtracks";
 122     fPWG2AODTracks->SetName(name);
 123
 124     fAOD->AddObject(fPWG2AODTracks);
 125
 126     //    TBranch *newBranch = fTreeA->Branch(name, &fPWG2AODTracks);
 127     fTreeA->Branch(name, &fPWG2AODTracks);
 128     fTreeA->GetUserInfo()->Add(fPWG2AODTracks);
 129
 130     // --- END PWG2 specific ---
 131 }
 132
 133 void AliAnalysisTaskPWG2ESDfilter::Init()
 134 {
 135     // Initialization
 136     if (fDebug > 1) AliInfo("Init() \n");
 137     // Call configuration file
 138 }
 139
 140 void AliAnalysisTaskPWG2ESDfilter::ConnectInputData(Option_t */*option*/)
 141 {
 142 // Connect the input data
 143 //
 144     if (fDebug > 1) AliInfo("ConnectInputData() \n");
 145     // Input
 146     AliESDInputHandler* esdH = (AliESDInputHandler*)
 147         ((AliAnalysisManager::GetAnalysisManager())->GetInputEventHandler());
 148     fESD = (AliESDEvent*) esdH->GetEvent();
 149     fTree = esdH->GetTree();
 150 }
 151
 152 void AliAnalysisTaskPWG2ESDfilter::Exec(Option_t */*option*/)
 153 {
 154 // Execute analysis for current event
 155 //
 156     // ESD Filter analysis task executed for each event
 157     AliESD* old = fESD->GetAliESDOld();
 158
 159     Long64_t ientry = fTree->GetReadEntry();
 160     printf("Filter: Analysing event # %5d\n", (Int_t) ientry);
 161
 162     // set arrays and pointers
 163     Double_t pos[3];
 164     Double_t p[3];
 165     Double_t covVtx[6];
 166     Double_t covTr[21];
 167     Double_t pid[10];
 168
 169     for (Int_t i = 0; i < 6; i++)  covVtx[i] = 0.;
 170     for (Int_t i = 0; i < 21; i++) covTr [i] = 0.;
 171
 172     // *** PWG2 specific ***
 173
 174     Double_t tpcentrancepoint[3];
 175     Double_t tpcexitpoint[3];
 176     TBits    sharemap;
 177     TBits    clustermap;
 178
 179     for (Int_t i = 0; i < 3; i++)  { tpcentrancepoint[i] = 0.; tpcexitpoint[i] = 0; }
 180
 181     // --- END PWG2 specific ---
 182
 183
 184   // loop over events and fill them
 185
 186   // Multiplicity information needed by the header (to be revised!)
 187     Int_t nTracks    = fESD->GetNumberOfTracks();
 188     Int_t nPosTracks = 0;
 189     for (Int_t iTrack = 0; iTrack < nTracks; ++iTrack)
 190         if (fESD->GetTrack(iTrack)->GetSign()> 0) nPosTracks++;
 191
 192     // Update the header
 193
 194     AliAODHeader* header = fAOD->GetHeader();
 195     header->SetRunNumber(fESD->GetRunNumber());
 196     if (old) {
 197         header->SetBunchCrossNumber(0);
 198         header->SetOrbitNumber(0);
 199         header->SetPeriodNumber(0);
 200         header->SetEventType(0);
 201         header->SetMuonMagFieldScale(-999.);
 202         header->SetCentrality(-999.);
 203     } else {
 204         header->SetBunchCrossNumber(fESD->GetBunchCrossNumber());
 205         header->SetOrbitNumber(fESD->GetOrbitNumber());
 206         header->SetPeriodNumber(fESD->GetPeriodNumber());
 207         header->SetEventType(fESD->GetEventType());
 208         header->SetMuonMagFieldScale(-999.);
 209         header->SetCentrality(-999.);
 210     }
 211
 212     header->SetTriggerMask(fESD->GetTriggerMask());
 213     header->SetTriggerCluster(fESD->GetTriggerCluster());
 214     header->SetMagneticField(fESD->GetMagneticField());
 215     header->SetZDCN1Energy(fESD->GetZDCN1Energy());
 216     header->SetZDCP1Energy(fESD->GetZDCP1Energy());
 217     header->SetZDCN2Energy(fESD->GetZDCN2Energy());
 218     header->SetZDCP2Energy(fESD->GetZDCP2Energy());
 219     header->SetZDCEMEnergy(fESD->GetZDCEMEnergy(0),fESD->GetZDCEMEnergy(1));
 220     header->SetRefMultiplicity(nTracks);
 221     header->SetRefMultiplicityPos(nPosTracks);
 222     header->SetRefMultiplicityNeg(nTracks - nPosTracks);
 223
 224
 225     Int_t nV0s      = fESD->GetNumberOfV0s();
 226     Int_t nCascades = fESD->GetNumberOfCascades();
 227     Int_t nKinks    = fESD->GetNumberOfKinks();
 228     Int_t nVertices = nV0s + nCascades + nKinks + 1 /* = prim. vtx*/;
 229     Int_t nJets     = 0;
 230     Int_t nCaloClus = fESD->GetNumberOfCaloClusters();
 231     Int_t nFmdClus  = 0;
 232     Int_t nPmdClus  = fESD->GetNumberOfPmdTracks();
 233
 234     printf("   NV0=%d  NCASCADES=%d  NKINKS=%d\n", nV0s, nCascades, nKinks);
 235
 236 //    fAOD->ResetStd(nTracks, nVertices, nV0s+nCascades, nJets, nCaloClus, nFmdClus, nPmdClus);
 237
 238     AliAODTrack *aodTrack;
 239
 240
 241     // Array to take into account the tracks already added to the AOD
 242     Bool_t * usedTrack = NULL;
 243     if (nTracks>0) {
 244         usedTrack = new Bool_t[nTracks];
 245         for (Int_t iTrack=0; iTrack<nTracks; ++iTrack) usedTrack[iTrack]=kFALSE;
 246     }
 247     // Array to take into account the V0s already added to the AOD
 248     Bool_t * usedV0 = NULL;
 249     if (nV0s>0) {
 250         usedV0 = new Bool_t[nV0s];
 251         for (Int_t iV0=0; iV0<nV0s; ++iV0) usedV0[iV0]=kFALSE;
 252     }
 253     // Array to take into account the kinks already added to the AOD
 254     Bool_t * usedKink = NULL;
 255     if (nKinks>0) {
 256         usedKink = new Bool_t[nKinks];
 257         for (Int_t iKink=0; iKink<nKinks; ++iKink) usedKink[iKink]=kFALSE;
 258     }
 259
 260     // Access to the AOD container of vertices
 261     TClonesArray &vertices = *(fAOD->GetVertices());
 262     Int_t jVertices=0;
 263
 264     // Access to the AOD container of tracks
 265     TClonesArray &tracks = *(fAOD->GetTracks());
 266     Int_t jTracks=0;
 267     Int_t pTracks=0;
 268
 269     // Add primary vertex. The primary tracks will be defined
 270     // after the loops on the composite objects (V0, cascades, kinks)
 271     const AliESDVertex *vtx = fESD->GetPrimaryVertex();
 272
 273     vtx->GetXYZ(pos); // position
 274     vtx->GetCovMatrix(covVtx); //covariance matrix
 275
 276     AliAODVertex * primary = new(vertices[jVertices++])
 277         AliAODVertex(pos, covVtx, vtx->GetChi2toNDF(), NULL, AliAODVertex::kPrimary);
 278     primary->Print();
 279
 280
 281     // Create vertices starting from the most complex objects
 282     Double_t chi2 = 0.;
 283
 284     // Cascades
 285     for (Int_t nCascade = 0; nCascade < nCascades; ++nCascade) {
 286         AliESDcascade *cascade = fESD->GetCascade(nCascade);
 287
 288         cascade->GetXYZ(pos[0], pos[1], pos[2]);
 289
 290         if (!old) {
 291             chi2 = vtx->GetChi2toNDF();
 292             cascade->GetPosCovXi(covVtx);
 293         } else {
 294             chi2 = -999.;
 295         }
 296         // Add the cascade vertex
 297         AliAODVertex * vcascade = new(vertices[jVertices++]) AliAODVertex(pos,
 298                                                                           covVtx,
 299                                                                           chi2, // = chi2/NDF since NDF = 2*2-3 (AM)
 300                                                                           primary,
 301                                                                           AliAODVertex::kCascade);
 302
 303         primary->AddDaughter(vcascade);
 304
 305         // Add the V0 from the cascade. The ESD class have to be optimized...
 306         // Now we have to search for the corresponding Vo in the list of V0s
 307         // using the indeces of the positive and negative tracks
 308
 309         Int_t posFromV0 = cascade->GetPindex();
 310         Int_t negFromV0 = cascade->GetNindex();
 311
 312
 313         AliESDv0 * v0 = 0x0;
 314         Int_t indV0 = -1;
 315
 316         for (Int_t iV0=0; iV0<nV0s; ++iV0) {
 317
 318             v0 = fESD->GetV0(iV0);
 319             Int_t posV0 = v0->GetPindex();
 320             Int_t negV0 = v0->GetNindex();
 321
 322             if (posV0==posFromV0 && negV0==negFromV0) {
 323                 indV0 = iV0;
 324                 break;
 325             }
 326         }
 327
 328         AliAODVertex * vV0FromCascade = 0x0;
 329
 330         if (indV0>-1 && !usedV0[indV0] ) {
 331
 332             // the V0 exists in the array of V0s and is not used
 333
 334             usedV0[indV0] = kTRUE;
 335
 336             v0->GetXYZ(pos[0], pos[1], pos[2]);
 337             if (!old) {
 338                 chi2 = v0->GetChi2V0();
 339                 v0->GetPosCov(covVtx);
 340             } else {
 341                 chi2 = -999.;
 342             }
 343
 344             vV0FromCascade = new(vertices[jVertices++]) AliAODVertex(pos,
 345                                                                      covVtx,
 346                                                                      chi2, // = chi2/NDF since NDF = 2*2-3 (AM)
 347                                                                      vcascade,
 348                                                                      AliAODVertex::kV0);
 349         } else {
 350
 351             // the V0 doesn't exist in the array of V0s or was used
 352 //          cerr << "Error: event " << fESD->GetEventNumberInFile() << " cascade " << nCascade
 353 //               << " The V0 " << indV0
 354 //               << " doesn't exist in the array of V0s or was used!" << endl;
 355
 356             cascade->GetXYZ(pos[0], pos[1], pos[2]);
 357
 358             if (!old) {
 359                 chi2 = v0->GetChi2V0();
 360                 cascade->GetPosCov(covVtx);
 361             } else {
 362                 chi2 = -999.;
 363             }
 364
 365             vV0FromCascade = new(vertices[jVertices++]) AliAODVertex(pos,
 366                                                                      covVtx,
 367                                                                      chi2, // = chi2/NDF since NDF = 2*2-3 (AM)
 368                                                                      vcascade,
 369                                                                      AliAODVertex::kV0);
 370             vcascade->AddDaughter(vV0FromCascade);
 371         }
 372
 373         // Add the positive tracks from the V0
 374
 375         if (posFromV0>-1 && !usedTrack[posFromV0]) {
 376
 377             usedTrack[posFromV0] = kTRUE;
 378
 379             AliESDtrack *esdTrack = fESD->GetTrack(posFromV0);
 380             esdTrack->GetPxPyPz(p);
 381             esdTrack->GetXYZ(pos);
 382             esdTrack->GetCovarianceXYZPxPyPz(covTr);
 383             esdTrack->GetESDpid(pid);
 384
 385             vV0FromCascade->AddDaughter(aodTrack =
 386                                         new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
 387                                                                            esdTrack->GetLabel(),
 388                                                                            p,
 389                                                                            kTRUE,
 390                                                                            pos,
 391                                                                            kFALSE,
 392                                                                            covTr,
 393                                                                            (Short_t)esdTrack->GetSign(),
 394                                                                            esdTrack->GetITSClusterMap(),
 395                                                                            pid,
 396                                                                            vV0FromCascade,
 397                                                                            kTRUE,  // check if this is right
 398                                                                            kFALSE, // check if this is right
 399                                                                            AliAODTrack::kSecondary)
 400                 );
 401             aodTrack->ConvertAliPIDtoAODPID();
 402         }
 403         else {
 404 //          cerr << "Error: event " << fESD->GetEventNumberInFile() << " cascade " << nCascade
 405 //               << " track " << posFromV0 << " has already been used!" << endl;
 406         }
 407
 408         // Add the negative tracks from the V0
 409
 410         if (negFromV0>-1 && !usedTrack[negFromV0]) {
 411
 412             usedTrack[negFromV0] = kTRUE;
 413
 414             AliESDtrack *esdTrack = fESD->GetTrack(negFromV0);
 415             esdTrack->GetPxPyPz(p);
 416             esdTrack->GetXYZ(pos);
 417             esdTrack->GetCovarianceXYZPxPyPz(covTr);
 418             esdTrack->GetESDpid(pid);
 419
 420             vV0FromCascade->AddDaughter(aodTrack =
 421                                         new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
 422                                                                            esdTrack->GetLabel(),
 423                                                                            p,
 424                                                                            kTRUE,
 425                                                                            pos,
 426                                                                            kFALSE,
 427                                                                            covTr,
 428                                                                            (Short_t)esdTrack->GetSign(),
 429                                                                            esdTrack->GetITSClusterMap(),
 430                                                                            pid,
 431                                                                            vV0FromCascade,
 432                                                                            kTRUE,  // check if this is right
 433                                                                            kFALSE, // check if this is right
 434                                                                            AliAODTrack::kSecondary)
 435                 );
 436             aodTrack->ConvertAliPIDtoAODPID();
 437         }
 438         else {
 439 //          cerr << "Error: event " << fESD->GetEventNumberInFile() << " cascade " << nCascade
 440 //               << " track " << negFromV0 << " has already been used!" << endl;
 441         }
 442
 443         // Add the bachelor track from the cascade
 444
 445         Int_t bachelor = cascade->GetBindex();
 446
 447         if(bachelor>-1 && !usedTrack[bachelor]) {
 448
 449             usedTrack[bachelor] = kTRUE;
 450
 451             AliESDtrack *esdTrack = fESD->GetTrack(bachelor);
 452             esdTrack->GetPxPyPz(p);
 453             esdTrack->GetXYZ(pos);
 454             esdTrack->GetCovarianceXYZPxPyPz(covTr);
 455             esdTrack->GetESDpid(pid);
 456
 457             vcascade->AddDaughter(aodTrack =
 458                                   new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
 459                                                                      esdTrack->GetLabel(),
 460                                                                      p,
 461                                                                      kTRUE,
 462                                                                      pos,
 463                                                                      kFALSE,
 464                                                                      covTr,
 465                                                                      (Short_t)esdTrack->GetSign(),
 466                                                                      esdTrack->GetITSClusterMap(),
 467                                                                      pid,
 468                                                                      vcascade,
 469                                                                      kTRUE,  // check if this is right
 470                                                                      kFALSE, // check if this is right
 471                                                                      AliAODTrack::kSecondary)
 472                 );
 473             aodTrack->ConvertAliPIDtoAODPID();
 474         }
 475         else {
 476 //          cerr << "Error: event " << fESD->GetEventNumberInFile() << " cascade " << nCascade
 477 //               << " track " << bachelor << " has already been used!" << endl;
 478         }
 479
 480         // Add the primary track of the cascade (if any)
 481
 482     } // end of the loop on cascades
 483
 484     // V0s
 485
 486     for (Int_t nV0 = 0; nV0 < nV0s; ++nV0) {
 487
 488         if (usedV0[nV0]) continue; // skip if aready added to the AOD
 489
 490         AliESDv0 *v0 = fESD->GetV0(nV0);
 491
 492         v0->GetXYZ(pos[0], pos[1], pos[2]);
 493
 494         if (!old) {
 495             chi2 = v0->GetChi2V0();
 496             v0->GetPosCov(covVtx);
 497         } else {
 498             chi2 = -999.;
 499         }
 500
 501
 502         AliAODVertex * vV0 =
 503             new(vertices[jVertices++]) AliAODVertex(pos,
 504                                                     covVtx,
 505                                                     chi2, // = chi2/NDF since NDF = 2*2-3
 506                                                     primary,
 507                                                     AliAODVertex::kV0);
 508         primary->AddDaughter(vV0);
 509
 510         Int_t posFromV0 = v0->GetPindex();
 511         Int_t negFromV0 = v0->GetNindex();
 512
 513         // Add the positive tracks from the V0
 514
 515         if (posFromV0>-1 && !usedTrack[posFromV0]) {
 516
 517             usedTrack[posFromV0] = kTRUE;
 518
 519             AliESDtrack *esdTrack = fESD->GetTrack(posFromV0);
 520             esdTrack->GetPxPyPz(p);
 521             esdTrack->GetXYZ(pos);
 522             esdTrack->GetCovarianceXYZPxPyPz(covTr);
 523             esdTrack->GetESDpid(pid);
 524
 525             vV0->AddDaughter(aodTrack =
 526                              new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
 527                                                                 esdTrack->GetLabel(),
 528                                                                 p,
 529                                                                 kTRUE,
 530                                                                 pos,
 531                                                                 kFALSE,
 532                                                                 covTr,
 533                                                                 (Short_t)esdTrack->GetSign(),
 534                                                                 esdTrack->GetITSClusterMap(),
 535                                                                 pid,
 536                                                                 vV0,
 537                                                                 kTRUE,  // check if this is right
 538                                                                 kFALSE, // check if this is right
 539                                                                 AliAODTrack::kSecondary)
 540                 );
 541             aodTrack->ConvertAliPIDtoAODPID();
 542         }
 543         else {
 544 //          cerr << "Error: event " << fESD->GetEventNumberInFile() << " V0 " << nV0
 545 //               << " track " << posFromV0 << " has already been used!" << endl;
 546         }
 547
 548         // Add the negative tracks from the V0
 549
 550         if (negFromV0>-1 && !usedTrack[negFromV0]) {
 551
 552             usedTrack[negFromV0] = kTRUE;
 553
 554             AliESDtrack *esdTrack = fESD->GetTrack(negFromV0);
 555             esdTrack->GetPxPyPz(p);
 556             esdTrack->GetXYZ(pos);
 557             esdTrack->GetCovarianceXYZPxPyPz(covTr);
 558             esdTrack->GetESDpid(pid);
 559
 560             vV0->AddDaughter(aodTrack =
 561                              new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
 562                                                                 esdTrack->GetLabel(),
 563                                                                 p,
 564                                                                 kTRUE,
 565                                                                 pos,
 566                                                                 kFALSE,
 567                                                                 covTr,
 568                                                                 (Short_t)esdTrack->GetSign(),
 569                                                                 esdTrack->GetITSClusterMap(),
 570                                                                 pid,
 571                                                                 vV0,
 572                                                                 kTRUE,  // check if this is right
 573                                                                 kFALSE, // check if this is right
 574                                                                 AliAODTrack::kSecondary)
 575                 );
 576             aodTrack->ConvertAliPIDtoAODPID();
 577         }
 578         else {
 579 //          cerr << "Error: event " << fESD->GetEventNumberInFile() << " V0 " << nV0
 580 //               << " track " << negFromV0 << " has already been used!" << endl;
 581         }
 582
 583     } // end of the loop on V0s
 584
 585     // Kinks: it is a big mess the access to the information in the kinks
 586     // The loop is on the tracks in order to find the mother and daugther of each kink
 587
 588
 589     for (Int_t iTrack=0; iTrack<nTracks; ++iTrack) {
 590
 591
 592         AliESDtrack * esdTrack = fESD->GetTrack(iTrack);
 593
 594         Int_t ikink = esdTrack->GetKinkIndex(0);
 595
 596         if (ikink && nKinks) {
 597             // Negative kink index: mother, positive: daughter
 598
 599             // Search for the second track of the kink
 600
 601             for (Int_t jTrack = iTrack+1; jTrack<nTracks; ++jTrack) {
 602
 603                 AliESDtrack * esdTrack1 = fESD->GetTrack(jTrack);
 604
 605                 Int_t jkink = esdTrack1->GetKinkIndex(0);
 606
 607                 if ( TMath::Abs(ikink)==TMath::Abs(jkink) ) {
 608
 609                     // The two tracks are from the same kink
 610
 611                     if (usedKink[TMath::Abs(ikink)-1]) continue; // skip used kinks
 612
 613                     Int_t imother = -1;
 614                     Int_t idaughter = -1;
 615
 616                     if (ikink<0 && jkink>0) {
 617
 618                         imother = iTrack;
 619                         idaughter = jTrack;
 620                     }
 621                     else if (ikink>0 && jkink<0) {
 622
 623                         imother = jTrack;
 624                         idaughter = iTrack;
 625                     }
 626                     else {
 627 //                      cerr << "Error: Wrong combination of kink indexes: "
 628 //                           << ikink << " " << jkink << endl;
 629                         continue;
 630                     }
 631
 632                     // Add the mother track
 633
 634                     AliAODTrack * mother = NULL;
 635
 636                     if (!usedTrack[imother]) {
 637
 638                         usedTrack[imother] = kTRUE;
 639
 640                         AliESDtrack *esdTrack = fESD->GetTrack(imother);
 641                         esdTrack->GetPxPyPz(p);
 642                         esdTrack->GetXYZ(pos);
 643                         esdTrack->GetCovarianceXYZPxPyPz(covTr);
 644                         esdTrack->GetESDpid(pid);
 645
 646                         mother =
 647                             new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
 648                                                                esdTrack->GetLabel(),
 649                                                                p,
 650                                                                kTRUE,
 651                                                                pos,
 652                                                                kFALSE,
 653                                                                covTr,
 654                                                                (Short_t)esdTrack->GetSign(),
 655                                                                esdTrack->GetITSClusterMap(),
 656                                                                pid,
 657                                                                primary,
 658                                                                kTRUE, // check if this is right
 659                                                                kTRUE, // check if this is right
 660                                                                AliAODTrack::kPrimary);
 661                         primary->AddDaughter(mother);
 662                         mother->ConvertAliPIDtoAODPID();
 663                     }
 664                     else {
 665 //                      cerr << "Error: event " << fESD->GetEventNumberInFile() << " kink " << TMath::Abs(ikink)-1
 666 //                           << " track " << imother << " has already been used!" << endl;
 667                   }
 668
 669                     // Add the kink vertex
 670                     AliESDkink * kink = fESD->GetKink(TMath::Abs(ikink)-1);
 671
 672                     AliAODVertex * vkink =
 673                         new(vertices[jVertices++]) AliAODVertex(kink->GetPosition(),
 674                                                                 NULL,
 675                                                                 0.,
 676                                                                 mother,
 677                                                                 AliAODVertex::kKink);
 678                     // Add the daughter track
 679
 680                     AliAODTrack * daughter = NULL;
 681
 682                     if (!usedTrack[idaughter]) {
 683
 684                         usedTrack[idaughter] = kTRUE;
 685
 686                         AliESDtrack *esdTrack = fESD->GetTrack(idaughter);
 687                         esdTrack->GetPxPyPz(p);
 688                         esdTrack->GetXYZ(pos);
 689                         esdTrack->GetCovarianceXYZPxPyPz(covTr);
 690                         esdTrack->GetESDpid(pid);
 691
 692                         daughter =
 693                             new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
 694                                                                esdTrack->GetLabel(),
 695                                                                p,
 696                                                                kTRUE,
 697                                                                pos,
 698                                                                kFALSE,
 699                                                                covTr,
 700                                                                (Short_t)esdTrack->GetSign(),
 701                                                                esdTrack->GetITSClusterMap(),
 702                                                                pid,
 703                                                                vkink,
 704                                                                kTRUE, // check if this is right
 705                                                                kTRUE, // check if this is right
 706                                                                AliAODTrack::kPrimary);
 707                         vkink->AddDaughter(daughter);
 708                         daughter->ConvertAliPIDtoAODPID();
 709                     }
 710                     else {
 711 //                      cerr << "Error: event " << fESD->GetEventNumberInFile() << " kink " << TMath::Abs(ikink)-1
 712 //                           << " track " << idaughter << " has already been used!" << endl;
 713                     }
 714                 }
 715             }
 716         }
 717     }
 718
 719
 720     // Tracks (primary and orphan)
 721
 722     printf("NUMBER OF TRACKS %5d\n", nTracks);
 723
 724     // *** PWG2 specific ***
 725
 726     fPWG2AODTracks->Delete();
 727     fPWG2AODTracks->Expand(nTracks);
 728     TClonesArray &tPWG2AODTracks = *fPWG2AODTracks;
 729
 730     // --- END PWG2 specific ---
 731
 732     for (Int_t nTrack = 0; nTrack < nTracks; ++nTrack) {
 733
 734         if (usedTrack[nTrack]) continue;
 735         AliESDtrack *esdTrack = fESD->GetTrack(nTrack);
 736         UInt_t selectInfo = 0;
 737         //
 738         // Track selection
 739         if (fTrackFilter) {
 740             selectInfo = fTrackFilter->IsSelected(esdTrack);
 741             if (!selectInfo) continue;
 742         }
 743
 744         //
 745         esdTrack->GetPxPyPz(p);
 746         esdTrack->GetXYZ(pos);
 747         esdTrack->GetCovarianceXYZPxPyPz(covTr);
 748         esdTrack->GetESDpid(pid);
 749
 750         Float_t impactXY, impactZ;
 751
 752         esdTrack->GetImpactParameters(impactXY,impactZ);
 753
 754         // *** PWG2 specific ***
 755
 756         sharemap = esdTrack->GetTPCSharedMap();
 757         clustermap = esdTrack->GetTPCClusterMap();
 758
 759         esdTrack->GetInnerXYZ(tpcentrancepoint);
 760         tpcentrancepoint[2] -= pos[2];
 761
 762         esdTrack->GetOuterXYZ(tpcexitpoint);
 763         tpcexitpoint[2] -= pos[2];
 764
 765         // --- END PWG2 specific ---
 766
 767
 768         if (impactXY<3) {
 769             // track inside the beam pipe
 770
 771             primary->AddDaughter(aodTrack =
 772                                  new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
 773                                                                     esdTrack->GetLabel(),
 774                                                                     p,
 775                                                                     kTRUE,
 776                                                                     pos,
 777                                                                     kFALSE,
 778                                                                     covTr,
 779                                                                     (Short_t)esdTrack->GetSign(),
 780                                                                     esdTrack->GetITSClusterMap(),
 781                                                                     pid,
 782                                                                     primary,
 783                                                                     kTRUE, // check if this is right
 784                                                                     kTRUE, // check if this is right
 785                                                                     AliAODTrack::kPrimary,
 786                                                                     selectInfo)
 787                 );
 788             aodTrack->ConvertAliPIDtoAODPID();
 789
 790             // *** PWG2 specific ****
 791             // Add the PWG2 info into the AOD
 792             new (tPWG2AODTracks[pTracks++]) AliPWG2AODTrack(tpcentrancepoint,
 793                                                             tpcexitpoint,
 794                                                             sharemap,
 795                                                             clustermap,
 796                                                             aodTrack);
 797             // --- END PWG2 specific ---
 798         }
 799         else {
 800             // outside the beam pipe: orphan track
 801             aodTrack =
 802                 new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
 803                                                    esdTrack->GetLabel(),
 804                                                    p,
 805                                                    kTRUE,
 806                                                    pos,
 807                                                    kFALSE,
 808                                                    covTr,
 809                                                    (Short_t)esdTrack->GetSign(),
 810                                                    esdTrack->GetITSClusterMap(),
 811                                                    pid,
 812                                                    NULL,
 813                                                    kFALSE, // check if this is right
 814                                                    kFALSE, // check if this is right
 815                                                    AliAODTrack::kOrphan,
 816                                                    selectInfo);
 817             aodTrack->ConvertAliPIDtoAODPID();
 818
 819             // *** PWG2 specific ****
 820             // Add the PWG2 info into the AOD
 821             new (tPWG2AODTracks[pTracks++]) AliPWG2AODTrack(tpcentrancepoint,
 822                                                             tpcexitpoint,
 823                                                             sharemap,
 824                                                             clustermap,
 825                                                             aodTrack);
 826             // --- END PWG2 specific ---
 827         }
 828     } // end of loop on tracks
 829
 830     // muon tracks
 831     Int_t nMuTracks = fESD->GetNumberOfMuonTracks();
 832     for (Int_t nMuTrack = 0; nMuTrack < nMuTracks; ++nMuTrack) {
 833
 834         AliESDMuonTrack *esdMuTrack = fESD->GetMuonTrack(nMuTrack);
 835         p[0] = esdMuTrack->Px();
 836         p[1] = esdMuTrack->Py();
 837         p[2] = esdMuTrack->Pz();
 838         pos[0] = primary->GetX();
 839         pos[1] = primary->GetY();
 840         pos[2] = primary->GetZ();
 841
 842         // has to be changed once the muon pid is provided by the ESD
 843         for (Int_t i = 0; i < 10; pid[i++] = 0.); pid[AliAODTrack::kMuon]=1.;
 844
 845         primary->AddDaughter(
 846             new(tracks[jTracks++]) AliAODTrack(0, // no ID provided
 847                                                0, // no label provided
 848                                                p,
 849                                                kTRUE,
 850                                                pos,
 851                                                kFALSE,
 852                                                NULL, // no covariance matrix provided
 853                                                (Short_t)-99, // no charge provided
 854                                                0, // no ITSClusterMap
 855                                                pid,
 856                                                primary,
 857                                                kTRUE,  // check if this is right
 858                                                kTRUE,  // not used for vertex fit
 859                                                AliAODTrack::kPrimary)
 860             );
 861     }
 862
 863     printf("   jTracks=%d  pTracks=%d PWG2=%d\n", jTracks, pTracks, fPWG2AODTracks->GetEntries());
 864
 865     delete [] usedTrack;
 866     delete [] usedV0;
 867     delete [] usedKink;
 868
 869
 870     //
 871     PostData(0, fTreeA);
 872     return;
 873 }
 874
 875 void AliAnalysisTaskPWG2ESDfilter::Terminate(Option_t */*option*/)
 876 {
 877 // Terminate analysis
 878 //
 879     if (fDebug > 1) printf("AnalysisESDfilter: Terminate() \n");
 880 }
 881