ANALYSIS/AliAnalysisTaskESDfilter.cxx

   1 /**************************************************************************\r
   2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *\r
   3  *                                                                        *\r
   4  * Author: The ALICE Off-line Project.                                    *\r
   5  * Contributors are mentioned in the code where appropriate.              *\r
   6  *                                                                        *\r
   7  * Permission to use, copy, modify and distribute this software and its   *\r
   8  * documentation strictly for non-commercial purposes is hereby granted   *\r
   9  * without fee, provided that the above copyright notice appears in all   *\r
  10  * copies and that both the copyright notice and this permission notice   *\r
  11  * appear in the supporting documentation. The authors make no claims     *\r
  12  * about the suitability of this software for any purpose. It is          *\r
  13  * provided "as is" without express or implied warranty.                  *\r
  14  **************************************************************************/\r
  15 \r
  16 /* $Id$ */\r
  17  \r
  18 #include <TChain.h>\r
  19 #include <TTree.h>\r
  20 #include <TList.h>\r
  21 #include <TArrayI.h>\r
  22 #include <TRandom.h>\r
  23 #include <TParticle.h>\r
  24 #include <TFile.h>\r
  25 \r
  26 #include "AliAnalysisTaskESDfilter.h"\r
  27 #include "AliAnalysisManager.h"\r
  28 #include "AliESDEvent.h"\r
  29 #include "AliESDRun.h"\r
  30 #include "AliStack.h"\r
  31 #include "AliAODEvent.h"\r
  32 #include "AliMCEvent.h"\r
  33 #include "AliMCEventHandler.h"\r
  34 #include "AliESDInputHandler.h"\r
  35 #include "AliAODHandler.h"\r
  36 #include "AliAODMCParticle.h"\r
  37 #include "AliAnalysisFilter.h"\r
  38 #include "AliESDMuonTrack.h"\r
  39 #include "AliESDVertex.h"\r
  40 #include "AliCentrality.h"\r
  41 #include "AliEventplane.h"\r
  42 #include "AliESDv0.h"\r
  43 #include "AliESDkink.h"\r
  44 #include "AliESDcascade.h"\r
  45 #include "AliESDPmdTrack.h"\r
  46 #include "AliESDCaloCluster.h"\r
  47 #include "AliESDCaloCells.h"\r
  48 #include "AliMultiplicity.h"\r
  49 #include "AliLog.h"\r
  50 #include "AliCodeTimer.h"\r
  51 #include "AliESDtrackCuts.h"\r
  52 #include "AliESDpid.h"\r
  53 #include "Riostream.h"\r
  54 \r
  55 ClassImp(AliAnalysisTaskESDfilter)\r
  56 \r
  57 ////////////////////////////////////////////////////////////////////////\r
  58 \r
  59 AliAnalysisTaskESDfilter::AliAnalysisTaskESDfilter():\r
  60     AliAnalysisTaskSE(),\r
  61     fTrackFilter(0x0),\r
  62     fKinkFilter(0x0),\r
  63     fV0Filter(0x0),\r
  64     fCascadeFilter(0x0),\r
  65     fHighPthreshold(0),\r
  66     fPtshape(0x0),\r
  67     fEnableFillAOD(kTRUE),\r
  68     fUsedTrack(0x0),\r
  69     fUsedKink(0x0),\r
  70     fUsedV0(0x0),\r
  71     fAODTrackRefs(0x0),\r
  72     fAODV0VtxRefs(0x0),\r
  73     fAODV0Refs(0x0),\r
  74     fMChandler(0x0),\r
  75     fNumberOfTracks(0),\r
  76     fNumberOfPositiveTracks(0),\r
  77     fNumberOfV0s(0),\r
  78     fNumberOfVertices(0),\r
  79     fNumberOfCascades(0),\r
  80     fNumberOfKinks(0),\r
  81     fOldESDformat(kFALSE),\r
  82     fPrimaryVertex(0x0),\r
  83     fTPCOnlyFilterMask(0),\r
  84     fHybridFilterMaskITSTPC(0),\r
  85     fHybridFilterMaskTPC0(0),\r
  86     fHybridFilterMaskTPC1(0),\r
  87     fIsVZEROEnabled(kTRUE),\r
  88     fIsZDCEnabled(kTRUE),\r
  89     fAreCascadesEnabled(kTRUE),\r
  90     fAreV0sEnabled(kTRUE),\r
  91     fAreKinksEnabled(kTRUE),\r
  92     fAreTracksEnabled(kTRUE),\r
  93     fArePmdClustersEnabled(kTRUE),\r
  94     fAreCaloClustersEnabled(kTRUE),\r
  95     fAreEMCALCellsEnabled(kTRUE),\r
  96     fArePHOSCellsEnabled(kTRUE),\r
  97     fAreTrackletsEnabled(kTRUE),\r
  98     fESDpid(0x0),\r
  99     fIsPidOwner(kFALSE),\r
 100     fTimeZeroType(AliESDpid::kTOF_T0),\r
 101     fTPCaloneTrackCuts(0)\r
 102 {\r
 103   // Default constructor\r
 104 }\r
 105 \r
 106 //______________________________________________________________________________\r
 107 AliAnalysisTaskESDfilter::AliAnalysisTaskESDfilter(const char* name):\r
 108     AliAnalysisTaskSE(name),\r
 109     fTrackFilter(0x0),\r
 110     fKinkFilter(0x0),\r
 111     fV0Filter(0x0),\r
 112     fCascadeFilter(0x0),\r
 113     fHighPthreshold(0),\r
 114     fPtshape(0x0),\r
 115     fEnableFillAOD(kTRUE),\r
 116     fUsedTrack(0x0),\r
 117     fUsedKink(0x0),\r
 118     fUsedV0(0x0),\r
 119     fAODTrackRefs(0x0),\r
 120     fAODV0VtxRefs(0x0),\r
 121     fAODV0Refs(0x0),\r
 122     fMChandler(0x0),\r
 123     fNumberOfTracks(0),\r
 124     fNumberOfPositiveTracks(0),\r
 125     fNumberOfV0s(0),\r
 126     fNumberOfVertices(0),\r
 127     fNumberOfCascades(0),\r
 128     fNumberOfKinks(0),\r
 129     fOldESDformat(kFALSE),\r
 130     fPrimaryVertex(0x0),\r
 131     fTPCOnlyFilterMask(0),\r
 132     fHybridFilterMaskITSTPC(0),\r
 133     fHybridFilterMaskTPC0(0),\r
 134     fHybridFilterMaskTPC1(0),\r
 135     fIsVZEROEnabled(kTRUE),\r
 136     fIsZDCEnabled(kTRUE),\r
 137     fAreCascadesEnabled(kTRUE),\r
 138     fAreV0sEnabled(kTRUE),\r
 139     fAreKinksEnabled(kTRUE),\r
 140     fAreTracksEnabled(kTRUE),\r
 141     fArePmdClustersEnabled(kTRUE),\r
 142     fAreCaloClustersEnabled(kTRUE),\r
 143     fAreEMCALCellsEnabled(kTRUE),\r
 144     fArePHOSCellsEnabled(kTRUE),\r
 145     fAreTrackletsEnabled(kTRUE),\r
 146     fESDpid(0x0),\r
 147     fIsPidOwner(kFALSE),\r
 148     fTimeZeroType(AliESDpid::kTOF_T0),\r
 149     fTPCaloneTrackCuts(0)\r
 150 {\r
 151   // Constructor\r
 152 }\r
 153 AliAnalysisTaskESDfilter::~AliAnalysisTaskESDfilter(){\r
 154     if(fIsPidOwner) delete fESDpid;\r
 155 }\r
 156 //______________________________________________________________________________\r
 157 void AliAnalysisTaskESDfilter::UserCreateOutputObjects()\r
 158 {\r
 159   //\r
 160   // Create Output Objects conenct filter to outputtree\r
 161   // \r
 162   if(OutputTree())\r
 163   {\r
 164     OutputTree()->GetUserInfo()->Add(fTrackFilter);\r
 165   }\r
 166   else\r
 167   {\r
 168     AliError("No OutputTree() for adding the track filter");\r
 169   }\r
 170   fTPCaloneTrackCuts = AliESDtrackCuts::GetStandardTPCOnlyTrackCuts();\r
 171 }\r
 172 \r
 173 //______________________________________________________________________________\r
 174 void AliAnalysisTaskESDfilter::Init()\r
 175 {\r
 176   // Initialization\r
 177   if (fDebug > 1) AliInfo("Init() \n");\r
 178   // Call configuration file\r
 179 }\r
 180 \r
 181 //______________________________________________________________________________\r
 182 void AliAnalysisTaskESDfilter::PrintTask(Option_t *option, Int_t indent) const\r
 183 {\r
 184   AliInfo("");\r
 185   \r
 186   AliAnalysisTaskSE::PrintTask(option,indent);\r
 187   \r
 188   TString spaces(' ',indent+3);\r
 189   \r
 190   cout << spaces.Data() << Form("Cascades     are %s",fAreCascadesEnabled ? "ENABLED":"DISABLED") << endl;\r
 191   cout << spaces.Data() << Form("V0s          are %s",fAreV0sEnabled ? "ENABLED":"DISABLED") << endl;\r
 192   cout << spaces.Data() << Form("Kinks        are %s",fAreKinksEnabled ? "ENABLED":"DISABLED") << endl;\r
 193   cout << spaces.Data() << Form("Tracks       are %s",fAreTracksEnabled ? "ENABLED":"DISABLED") << endl;\r
 194   cout << spaces.Data() << Form("PmdClusters  are %s",fArePmdClustersEnabled ? "ENABLED":"DISABLED") << endl;\r
 195   cout << spaces.Data() << Form("CaloClusters are %s",fAreCaloClustersEnabled ? "ENABLED":"DISABLED") << endl;\r
 196   cout << spaces.Data() << Form("EMCAL cells  are %s",fAreEMCALCellsEnabled ? "ENABLED":"DISABLED") << endl;\r
 197   cout << spaces.Data() << Form("Tracklets    are %s",fAreTrackletsEnabled ? "ENABLED":"DISABLED") << endl;  \r
 198 }\r
 199 \r
 200 //______________________________________________________________________________\r
 201 void AliAnalysisTaskESDfilter::UserExec(Option_t */*option*/)\r
 202 {\r
 203 // Execute analysis for current event\r
 204 //\r
 205                                             \r
 206   Long64_t ientry = Entry();\r
 207   \r
 208   if (fDebug > 0) {\r
 209       printf("Filter: Analysing event # %5d\n", (Int_t) ientry);\r
 210       if (fHighPthreshold == 0) AliInfo("detector PID signals are stored in each track");\r
 211       if (!fPtshape) AliInfo("detector PID signals are not stored below the pt threshold");\r
 212   }\r
 213   // Filters must explicitely enable AOD filling in their UserExec (AG)\r
 214   if (!AliAnalysisManager::GetAnalysisManager()->GetOutputEventHandler()) AliFatal("Cannot run ESD filter without an output event handler");\r
 215   if(fEnableFillAOD) {\r
 216      AliAnalysisManager::GetAnalysisManager()->GetOutputEventHandler()->SetFillAOD(kTRUE);\r
 217      AliAnalysisManager::GetAnalysisManager()->GetOutputEventHandler()->SetFillExtension(kTRUE);\r
 218   }   \r
 219   ConvertESDtoAOD();\r
 220 }\r
 221 \r
 222 //______________________________________________________________________________\r
 223 TClonesArray& AliAnalysisTaskESDfilter::Cascades()\r
 224 {\r
 225   return *(AODEvent()->GetCascades());\r
 226 }\r
 227 \r
 228 //______________________________________________________________________________\r
 229 TClonesArray& AliAnalysisTaskESDfilter::Tracks()\r
 230 {\r
 231   return *(AODEvent()->GetTracks());\r
 232 }\r
 233 \r
 234 //______________________________________________________________________________\r
 235 TClonesArray& AliAnalysisTaskESDfilter::V0s()\r
 236 {\r
 237   return *(AODEvent()->GetV0s());\r
 238 }\r
 239 \r
 240 //______________________________________________________________________________\r
 241 TClonesArray& AliAnalysisTaskESDfilter::Vertices()\r
 242 {\r
 243   return *(AODEvent()->GetVertices());\r
 244 }\r
 245 \r
 246 //______________________________________________________________________________\r
 247 AliAODHeader* AliAnalysisTaskESDfilter::ConvertHeader(const AliESDEvent& esd)\r
 248 {\r
 249   AliCodeTimerAuto("",0);\r
 250   \r
 251   AliAODHeader* header = AODEvent()->GetHeader();\r
 252   \r
 253   header->SetRunNumber(esd.GetRunNumber());\r
 254   header->SetOfflineTrigger(fInputHandler->IsEventSelected()); // propagate the decision of the physics selection\r
 255 \r
 256   TTree* tree = fInputHandler->GetTree();\r
 257   if (tree) {\r
 258     TFile* file = tree->GetCurrentFile();\r
 259     if (file) header->SetESDFileName(file->GetName());\r
 260   }\r
 261   \r
 262   if (fOldESDformat) {\r
 263     header->SetBunchCrossNumber(0);\r
 264     header->SetOrbitNumber(0);\r
 265     header->SetPeriodNumber(0);\r
 266     header->SetEventType(0);\r
 267     header->SetMuonMagFieldScale(-999.);\r
 268     header->SetCentrality(0);       \r
 269     header->SetEventplane(0);\r
 270   } else {\r
 271     header->SetBunchCrossNumber(esd.GetBunchCrossNumber());\r
 272     header->SetOrbitNumber(esd.GetOrbitNumber());\r
 273     header->SetPeriodNumber(esd.GetPeriodNumber());\r
 274     header->SetEventType(esd.GetEventType());\r
 275     \r
 276     header->SetEventNumberESDFile(esd.GetHeader()->GetEventNumberInFile());\r
 277     if(const_cast<AliESDEvent&>(esd).GetCentrality()){\r
 278       header->SetCentrality(const_cast<AliESDEvent&>(esd).GetCentrality());\r
 279     }\r
 280     else{\r
 281       header->SetCentrality(0);\r
 282     }\r
 283     if(const_cast<AliESDEvent&>(esd).GetEventplane()){\r
 284       header->SetEventplane(const_cast<AliESDEvent&>(esd).GetEventplane());\r
 285     }\r
 286     else{\r
 287       header->SetEventplane(0);\r
 288     }\r
 289   }\r
 290   \r
 291   // Trigger\r
 292   header->SetFiredTriggerClasses(esd.GetFiredTriggerClasses());\r
 293   header->SetTriggerMask(esd.GetTriggerMask()); \r
 294   header->SetTriggerCluster(esd.GetTriggerCluster());\r
 295   header->SetL0TriggerInputs(esd.GetHeader()->GetL0TriggerInputs());    \r
 296   header->SetL1TriggerInputs(esd.GetHeader()->GetL1TriggerInputs());    \r
 297   header->SetL2TriggerInputs(esd.GetHeader()->GetL2TriggerInputs());    \r
 298   \r
 299   header->SetMagneticField(esd.GetMagneticField());\r
 300   header->SetMuonMagFieldScale(esd.GetCurrentDip()/6000.);\r
 301   header->SetZDCN1Energy(esd.GetZDCN1Energy());\r
 302   header->SetZDCP1Energy(esd.GetZDCP1Energy());\r
 303   header->SetZDCN2Energy(esd.GetZDCN2Energy());\r
 304   header->SetZDCP2Energy(esd.GetZDCP2Energy());\r
 305   header->SetZDCEMEnergy(esd.GetZDCEMEnergy(0),esd.GetZDCEMEnergy(1));\r
 306   \r
 307   // ITS Cluster Multiplicty\r
 308   const AliMultiplicity *mult = esd.GetMultiplicity();\r
 309   for (Int_t ilay = 0; ilay < 6; ilay++) header->SetITSClusters(ilay, mult->GetNumberOfITSClusters(ilay));\r
 310   \r
 311   // TPC only Reference Multiplicty\r
 312   Int_t refMult  = fTPCaloneTrackCuts ? (Short_t)fTPCaloneTrackCuts->GetReferenceMultiplicity(&esd, kTRUE) : -1;\r
 313   header->SetTPConlyRefMultiplicity(refMult);\r
 314   \r
 315   //\r
 316   Float_t diamxy[2]={esd.GetDiamondX(),esd.GetDiamondY()};\r
 317   Float_t diamcov[3]; \r
 318   esd.GetDiamondCovXY(diamcov);\r
 319   header->SetDiamond(diamxy,diamcov);\r
 320   header->SetDiamondZ(esd.GetDiamondZ(),esd.GetSigma2DiamondZ());\r
 321   \r
 322   return header;\r
 323 }\r
 324 \r
 325 //______________________________________________________________________________\r
 326 void AliAnalysisTaskESDfilter::ConvertCascades(const AliESDEvent& esd) \r
 327 {\r
 328   // Convert the cascades part of the ESD.\r
 329   // Return the number of cascades\r
 330  \r
 331   AliCodeTimerAuto("",0);\r
 332   \r
 333   // Create vertices starting from the most complex objects\r
 334   Double_t chi2 = 0.;\r
 335   \r
 336   const AliESDVertex* vtx = esd.GetPrimaryVertex();\r
 337   Double_t pos[3] = { 0. };\r
 338   Double_t covVtx[6] = { 0. };\r
 339   Double_t momBach[3]={0.};\r
 340   Double_t covTr[21]={0.};\r
 341   Double_t pid[10]={0.};\r
 342   AliAODPid* detpid(0x0);\r
 343   AliAODVertex* vV0FromCascade(0x0);\r
 344   AliAODv0* aodV0(0x0);\r
 345   AliAODcascade* aodCascade(0x0);\r
 346   AliAODTrack* aodTrack(0x0);\r
 347   Double_t momPos[3]={0.};\r
 348   Double_t momNeg[3] = { 0. };\r
 349   Double_t momPosAtV0vtx[3]={0.};\r
 350   Double_t momNegAtV0vtx[3]={0.};\r
 351 \r
 352   TClonesArray& verticesArray = Vertices();\r
 353   TClonesArray& tracksArray = Tracks();\r
 354   TClonesArray& cascadesArray = Cascades();\r
 355   \r
 356   // Cascades (Modified by A.Maire - February 2009)\r
 357   for (Int_t nCascade = 0; nCascade < esd.GetNumberOfCascades(); ++nCascade) {\r
 358     \r
 359     // 0- Preparation\r
 360     //\r
 361     AliESDcascade *esdCascade = esd.GetCascade(nCascade);\r
 362                 Int_t  idxPosFromV0Dghter  = esdCascade->GetPindex();\r
 363                 Int_t  idxNegFromV0Dghter  = esdCascade->GetNindex();\r
 364                 Int_t  idxBachFromCascade  = esdCascade->GetBindex();\r
 365     \r
 366     AliESDtrack  *esdCascadePos  = esd.GetTrack( idxPosFromV0Dghter);\r
 367     AliESDtrack  *esdCascadeNeg  = esd.GetTrack( idxNegFromV0Dghter);\r
 368     AliESDtrack  *esdCascadeBach = esd.GetTrack( idxBachFromCascade);\r
 369     \r
 370     // Identification of the V0 within the esdCascade (via both daughter track indices)\r
 371     AliESDv0 * currentV0   = 0x0;\r
 372     Int_t      idxV0FromCascade = -1;\r
 373     \r
 374     for (Int_t iV0=0; iV0<esd.GetNumberOfV0s(); ++iV0) {\r
 375       \r
 376       currentV0 = esd.GetV0(iV0);\r
 377       Int_t posCurrentV0 = currentV0->GetPindex();\r
 378       Int_t negCurrentV0 = currentV0->GetNindex();\r
 379       \r
 380       if (posCurrentV0==idxPosFromV0Dghter && negCurrentV0==idxNegFromV0Dghter) {\r
 381         idxV0FromCascade = iV0;\r
 382         break;\r
 383       }\r
 384     }\r
 385     \r
 386     if(idxV0FromCascade < 0){\r
 387       printf("Cascade - no matching for the V0 (index V0 = -1) ! Skip ... \n");\r
 388       continue;\r
 389     }// a priori, useless check, but safer ... in case of pb with tracks "out of bounds"\r
 390     \r
 391     AliESDv0 *esdV0FromCascade   = esd.GetV0(idxV0FromCascade);\r
 392         \r
 393     // 1 - Cascade selection \r
 394     \r
 395     //  AliESDVertex *esdPrimVtx = new AliESDVertex(*(esd.GetPrimaryVertex()));\r
 396     //  TList cascadeObjects;\r
 397     //  cascadeObjects.AddAt(esdV0FromCascade, 0);\r
 398     //  cascadeObjects.AddAt(esdCascadePos,    1);\r
 399     //  cascadeObjects.AddAt(esdCascadeNeg,    2);\r
 400     //  cascadeObjects.AddAt(esdCascade,       3);\r
 401     //  cascadeObjects.AddAt(esdCascadeBach,   4);\r
 402     //  cascadeObjects.AddAt(esdPrimVtx,       5);\r
 403     // \r
 404     //  UInt_t selectCascade = 0;\r
 405     //  if (fCascadeFilter) {\r
 406     //    // selectCascade = fCascadeFilter->IsSelected(&cascadeObjects); \r
 407     //          // FIXME AliESDCascadeCuts to be implemented ...\r
 408     // \r
 409     //          // Here we may encounter a moot point at the V0 level \r
 410     //          // between the cascade selections and the V0 ones :\r
 411     //          // the V0 selected along with the cascade (secondary V0) may \r
 412     //          // usually be removed from the dedicated V0 selections (prim V0) ...\r
 413     //          // -> To be discussed !\r
 414     // \r
 415     //    // this is a little awkward but otherwise the \r
 416     //    // list wants to access the pointer (delete it) \r
 417     //    // again when going out of scope\r
 418     //    delete cascadeObjects.RemoveAt(5); // esdPrimVtx created via copy construct\r
 419     //    esdPrimVtx = 0;\r
 420     //    if (!selectCascade) \r
 421     //      continue;\r
 422     //  }\r
 423     //  else{\r
 424     //    delete cascadeObjects.RemoveAt(5); // esdPrimVtx created via copy construct\r
 425     //    esdPrimVtx = 0;\r
 426     //  }\r
 427     \r
 428     // 2 - Add the cascade vertex\r
 429     \r
 430     esdCascade->GetXYZcascade(pos[0], pos[1], pos[2]);\r
 431     esdCascade->GetPosCovXi(covVtx);\r
 432     chi2 = esdCascade->GetChi2Xi(); \r
 433     \r
 434     AliAODVertex *vCascade = new(verticesArray[fNumberOfVertices++]) AliAODVertex( pos,\r
 435                                                                      covVtx,\r
 436                                                                      chi2, // FIXME = Chi2/NDF will be needed\r
 437                                                                      fPrimaryVertex,\r
 438                                                                      nCascade, // id\r
 439                                                                      AliAODVertex::kCascade);\r
 440     fPrimaryVertex->AddDaughter(vCascade);\r
 441     \r
 442 //    if (fDebug > 2) {\r
 443 //      printf("---- Cascade / Cascade Vertex (AOD) : \n");\r
 444 //      vCascade->Print();\r
 445 //    }\r
 446     \r
 447     if(esd.GetTOFHeader() && fIsPidOwner) fESDpid->SetTOFResponse(const_cast<AliESDEvent*>(&esd), (AliESDpid::EStartTimeType_t)fTimeZeroType); //in case of AOD production strating form LHC10e without Tender. \r
 448 \r
 449 \r
 450     // 3 - Add the bachelor track from the cascade\r
 451     \r
 452     if (!fUsedTrack[idxBachFromCascade]) {\r
 453       \r
 454       esdCascadeBach->GetPxPyPz(momBach);\r
 455       esdCascadeBach->GetXYZ(pos);\r
 456       esdCascadeBach->GetCovarianceXYZPxPyPz(covTr);\r
 457       esdCascadeBach->GetESDpid(pid);\r
 458       \r
 459             fUsedTrack[idxBachFromCascade] = kTRUE;\r
 460             UInt_t selectInfo = 0;\r
 461             if (fTrackFilter) selectInfo = fTrackFilter->IsSelected(esdCascadeBach);\r
 462             if (fMChandler) fMChandler->SelectParticle(esdCascadeBach->GetLabel());\r
 463             aodTrack = new(tracksArray[fNumberOfTracks++]) AliAODTrack(esdCascadeBach->GetID(),\r
 464                                                                            esdCascadeBach->GetLabel(), \r
 465                                                                            momBach, \r
 466                                                                            kTRUE,\r
 467                                                                            pos,\r
 468                                                                            kFALSE, // Why kFALSE for "isDCA" ? FIXME\r
 469                                                                            covTr, \r
 470                                                                            (Short_t)esdCascadeBach->GetSign(),\r
 471                                                                            esdCascadeBach->GetITSClusterMap(), \r
 472                                                                            pid,\r
 473                                                                            vCascade,\r
 474                                                                            kTRUE,  // usedForVtxFit = kFALSE ? FIXME\r
 475                                                                            vtx->UsesTrack(esdCascadeBach->GetID()),\r
 476                                                                            AliAODTrack::kSecondary,\r
 477                                                                            selectInfo);\r
 478             aodTrack->SetTPCClusterMap(esdCascadeBach->GetTPCClusterMap());\r
 479             aodTrack->SetTPCSharedMap (esdCascadeBach->GetTPCSharedMap());\r
 480             aodTrack->SetChi2perNDF(Chi2perNDF(esdCascadeBach));\r
 481             aodTrack->SetTPCPointsF(esdCascadeBach->GetTPCNclsF());\r
 482             fAODTrackRefs->AddAt(aodTrack,idxBachFromCascade);\r
 483             \r
 484             if (esdCascadeBach->GetSign() > 0) ++fNumberOfPositiveTracks;\r
 485             aodTrack->ConvertAliPIDtoAODPID();\r
 486             aodTrack->SetFlags(esdCascadeBach->GetStatus());\r
 487       SetAODPID(esdCascadeBach,aodTrack,detpid);\r
 488     }\r
 489     else {\r
 490             aodTrack = static_cast<AliAODTrack*>( fAODTrackRefs->At(idxBachFromCascade) );\r
 491     }\r
 492     \r
 493     vCascade->AddDaughter(aodTrack);\r
 494     \r
 495 //    if (fDebug > 4) {\r
 496 //      printf("---- Cascade / bach dghter : \n");\r
 497 //      aodTrack->Print();\r
 498 //    }\r
 499     \r
 500     \r
 501     // 4 - Add the V0 from the cascade. \r
 502     // = V0vtx + both pos and neg daughter tracks + the aodV0 itself\r
 503     //\r
 504     \r
 505     if ( !fUsedV0[idxV0FromCascade] ) {\r
 506       // 4.A - if VO structure hasn't been created yet\r
 507       \r
 508       // 4.A.1 - Create the V0 vertex of the cascade\r
 509       \r
 510       esdV0FromCascade->GetXYZ(pos[0], pos[1], pos[2]);\r
 511       esdV0FromCascade->GetPosCov(covVtx);\r
 512       chi2 = esdV0FromCascade->GetChi2V0();  // = chi2/NDF since NDF = 2*2-3 ?\r
 513                         \r
 514       vV0FromCascade = new(verticesArray[fNumberOfVertices++]) AliAODVertex(pos,\r
 515                                                                          covVtx,\r
 516                                                                          chi2,\r
 517                                                                          vCascade,\r
 518                                                                          idxV0FromCascade, //id of ESDv0\r
 519                                                                          AliAODVertex::kV0);\r
 520       // Note:\r
 521       //    one V0 can be used by several cascades.\r
 522       // So, one AOD V0 vtx can have several parent vtx.\r
 523       // This is not directly allowed by AliAODvertex.\r
 524       // Setting the parent vtx (here = param "vCascade") doesn't lead to a crash\r
 525       // but to a problem of consistency within AODEvent.\r
 526       // -> See below paragraph 4.B, for the proposed treatment of such a case.\r
 527       \r
 528       // Add the vV0FromCascade to the aodVOVtxRefs\r
 529       fAODV0VtxRefs->AddAt(vV0FromCascade,idxV0FromCascade);\r
 530       \r
 531       \r
 532       // 4.A.2 - Add the positive tracks from the V0\r
 533       \r
 534       esdCascadePos->GetPxPyPz(momPos);\r
 535       esdCascadePos->GetXYZ(pos);\r
 536       esdCascadePos->GetCovarianceXYZPxPyPz(covTr);\r
 537       esdCascadePos->GetESDpid(pid);\r
 538       \r
 539       \r
 540       if (!fUsedTrack[idxPosFromV0Dghter]) {\r
 541         fUsedTrack[idxPosFromV0Dghter] = kTRUE;\r
 542         \r
 543         UInt_t selectInfo = 0;\r
 544         if (fTrackFilter) selectInfo = fTrackFilter->IsSelected(esdCascadePos);\r
 545         if(fMChandler) fMChandler->SelectParticle(esdCascadePos->GetLabel());\r
 546         aodTrack = new(tracksArray[fNumberOfTracks++]) \r
 547         AliAODTrack(  esdCascadePos->GetID(),\r
 548                     esdCascadePos->GetLabel(), \r
 549                     momPos, \r
 550                     kTRUE,\r
 551                     pos,\r
 552                     kFALSE, // Why kFALSE for "isDCA" ? FIXME\r
 553                     covTr, \r
 554                     (Short_t)esdCascadePos->GetSign(),\r
 555                     esdCascadePos->GetITSClusterMap(), \r
 556                     pid,\r
 557                     vV0FromCascade,\r
 558                     kTRUE,  // usedForVtxFit = kFALSE ? FIXME\r
 559                     vtx->UsesTrack(esdCascadePos->GetID()),\r
 560                     AliAODTrack::kSecondary,\r
 561                     selectInfo);\r
 562         aodTrack->SetTPCClusterMap(esdCascadePos->GetTPCClusterMap());\r
 563         aodTrack->SetTPCSharedMap (esdCascadePos->GetTPCSharedMap());\r
 564         aodTrack->SetChi2perNDF(Chi2perNDF(esdCascadePos));\r
 565         aodTrack->SetTPCPointsF(esdCascadePos->GetTPCNclsF());\r
 566         fAODTrackRefs->AddAt(aodTrack,idxPosFromV0Dghter);\r
 567         \r
 568         if (esdCascadePos->GetSign() > 0) ++fNumberOfPositiveTracks;\r
 569         aodTrack->ConvertAliPIDtoAODPID();\r
 570         aodTrack->SetFlags(esdCascadePos->GetStatus());\r
 571         SetAODPID(esdCascadePos,aodTrack,detpid);\r
 572       }\r
 573       else {\r
 574         aodTrack = static_cast<AliAODTrack*>(fAODTrackRefs->At(idxPosFromV0Dghter));\r
 575       }\r
 576       vV0FromCascade->AddDaughter(aodTrack);\r
 577       \r
 578       \r
 579       // 4.A.3 - Add the negative tracks from the V0\r
 580       \r
 581       esdCascadeNeg->GetPxPyPz(momNeg);\r
 582       esdCascadeNeg->GetXYZ(pos);\r
 583       esdCascadeNeg->GetCovarianceXYZPxPyPz(covTr);\r
 584       esdCascadeNeg->GetESDpid(pid);\r
 585       \r
 586       \r
 587       if (!fUsedTrack[idxNegFromV0Dghter]) {\r
 588         fUsedTrack[idxNegFromV0Dghter] = kTRUE;\r
 589         \r
 590         UInt_t selectInfo = 0;\r
 591         if (fTrackFilter) selectInfo = fTrackFilter->IsSelected(esdCascadeNeg);\r
 592         if(fMChandler)fMChandler->SelectParticle(esdCascadeNeg->GetLabel());\r
 593         aodTrack = new(tracksArray[fNumberOfTracks++]) AliAODTrack(  esdCascadeNeg->GetID(),\r
 594                                                       esdCascadeNeg->GetLabel(),\r
 595                                                       momNeg,\r
 596                                                       kTRUE,\r
 597                                                       pos,\r
 598                                                       kFALSE, // Why kFALSE for "isDCA" ? FIXME\r
 599                                                       covTr, \r
 600                                                       (Short_t)esdCascadeNeg->GetSign(),\r
 601                                                       esdCascadeNeg->GetITSClusterMap(), \r
 602                                                       pid,\r
 603                                                       vV0FromCascade,\r
 604                                                       kTRUE,  // usedForVtxFit = kFALSE ? FIXME\r
 605                                                       vtx->UsesTrack(esdCascadeNeg->GetID()),\r
 606                                                       AliAODTrack::kSecondary,\r
 607                                                       selectInfo);\r
 608         aodTrack->SetTPCClusterMap(esdCascadeNeg->GetTPCClusterMap());\r
 609         aodTrack->SetTPCSharedMap (esdCascadeNeg->GetTPCSharedMap());\r
 610         aodTrack->SetChi2perNDF(Chi2perNDF(esdCascadeNeg));\r
 611         aodTrack->SetTPCPointsF(esdCascadeNeg->GetTPCNclsF());\r
 612         fAODTrackRefs->AddAt(aodTrack,idxNegFromV0Dghter);\r
 613         \r
 614         if (esdCascadeNeg->GetSign() > 0) ++fNumberOfPositiveTracks;\r
 615         aodTrack->ConvertAliPIDtoAODPID();\r
 616         aodTrack->SetFlags(esdCascadeNeg->GetStatus());\r
 617         SetAODPID(esdCascadeNeg,aodTrack,detpid);\r
 618       }\r
 619       else {\r
 620         aodTrack = static_cast<AliAODTrack*>(fAODTrackRefs->At(idxNegFromV0Dghter));\r
 621       }\r
 622       \r
 623       vV0FromCascade->AddDaughter(aodTrack);\r
 624       \r
 625                         \r
 626       // 4.A.4 - Add the V0 from cascade to the V0 array\r
 627       \r
 628       Double_t  dcaV0Daughters      = esdV0FromCascade->GetDcaV0Daughters();\r
 629       Double_t  dcaV0ToPrimVertex   = esdV0FromCascade->GetD( esd.GetPrimaryVertex()->GetX(),\r
 630                                                              esd.GetPrimaryVertex()->GetY(),\r
 631                                                              esd.GetPrimaryVertex()->GetZ() );\r
 632       esdV0FromCascade->GetPPxPyPz( momPosAtV0vtx[0],momPosAtV0vtx[1],momPosAtV0vtx[2] ); \r
 633       esdV0FromCascade->GetNPxPyPz( momNegAtV0vtx[0],momNegAtV0vtx[1],momNegAtV0vtx[2] ); \r
 634       \r
 635       Double_t dcaDaughterToPrimVertex[2] = { 999., 999.}; // ..[0] = DCA in (x,y) for Pos and ..[1] = Neg\r
 636       dcaDaughterToPrimVertex[0] = TMath::Abs(esdCascadePos->GetD(      esd.GetPrimaryVertex()->GetX(),\r
 637                                                                   esd.GetPrimaryVertex()->GetY(),\r
 638                                                                   esd.GetMagneticField())        );\r
 639       dcaDaughterToPrimVertex[1] = TMath::Abs(esdCascadeNeg->GetD(      esd.GetPrimaryVertex()->GetX(),\r
 640                                                                   esd.GetPrimaryVertex()->GetY(),\r
 641                                                                   esd.GetMagneticField())        );\r
 642       \r
 643       aodV0 = new(V0s()[fNumberOfV0s++]) AliAODv0( vV0FromCascade, \r
 644                                                   dcaV0Daughters,\r
 645                                                   dcaV0ToPrimVertex, \r
 646                                                   momPosAtV0vtx, \r
 647                                                   momNegAtV0vtx, \r
 648                                                   dcaDaughterToPrimVertex); \r
 649       // set the aod v0 on-the-fly status\r
 650       aodV0->SetOnFlyStatus(esdV0FromCascade->GetOnFlyStatus());\r
 651       \r
 652       // Add the aodV0 to the aodVORefs\r
 653       fAODV0Refs->AddAt(aodV0,idxV0FromCascade);\r
 654       \r
 655       fUsedV0[idxV0FromCascade] = kTRUE;\r
 656       \r
 657     } else { \r
 658       // 4.B - if V0 structure already used\r
 659       \r
 660       // Note :\r
 661       //    one V0 can be used by several cascades (frequent in PbPb evts) : \r
 662       // same V0 which used but attached to different bachelor tracks\r
 663       // -> aodVORefs and fAODV0VtxRefs are needed.\r
 664       // Goal : avoid a redundancy of the info in "Vertices" and "v0s" clones array.\r
 665       \r
 666       vV0FromCascade = static_cast<AliAODVertex*>( fAODV0VtxRefs->At(idxV0FromCascade) );\r
 667       aodV0          = static_cast<AliAODv0*>    ( fAODV0Refs   ->At(idxV0FromCascade) );\r
 668       \r
 669       // - Treatment of the parent for such a "re-used" V0 :\r
 670       // Insert the cascade that reuses the V0 vertex in the lineage chain\r
 671       // Before : vV0 -> vCascade1 -> vPrimary\r
 672       //  - Hyp : cascade2 uses the same V0 as cascade1\r
 673       //  After :  vV0 -> vCascade2 -> vCascade1 -> vPrimary\r
 674       \r
 675       AliAODVertex *vCascadePreviousParent = static_cast<AliAODVertex*> (vV0FromCascade->GetParent());\r
 676                         vV0FromCascade->SetParent(vCascade);\r
 677                         vCascade      ->SetParent(vCascadePreviousParent);\r
 678       \r
 679 //      if(fDebug > 2)  \r
 680 //        printf("---- Cascade / Lineage insertion\n"\r
 681 //               "Parent of V0 vtx                 = Cascade vtx %p\n"\r
 682 //               "Parent of the cascade vtx        = Cascade vtx %p\n"\r
 683 //               "Parent of the parent cascade vtx = Cascade vtx %p\n", \r
 684 //               static_cast<void*> (vV0FromCascade->GetParent()),\r
 685 //               static_cast<void*> (vCascade->GetParent()),\r
 686 //               static_cast<void*> (vCascadePreviousParent->GetParent()) );\r
 687       \r
 688     }// end if V0 structure already used\r
 689     \r
 690 //    if (fDebug > 2) {\r
 691 //      printf("---- Cascade / V0 vertex: \n");\r
 692 //      vV0FromCascade->Print();\r
 693 //    }\r
 694 //    \r
 695 //    if (fDebug > 4) {\r
 696 //      printf("---- Cascade / pos dghter : \n");\r
 697 //                      aodTrack->Print();\r
 698 //      printf("---- Cascade / neg dghter : \n");\r
 699 //                      aodTrack->Print();\r
 700 //      printf("---- Cascade / aodV0 : \n");\r
 701 //                      aodV0->Print();\r
 702 //    }\r
 703     \r
 704     // In any case (used V0 or not), add the V0 vertex to the cascade one.\r
 705     vCascade->AddDaughter(vV0FromCascade);      \r
 706     \r
 707                 \r
 708     // 5 - Add the primary track of the cascade (if any)\r
 709     \r
 710     \r
 711     // 6 - Add the cascade to the AOD array of cascades\r
 712     \r
 713     Double_t dcaBachToPrimVertexXY = TMath::Abs(esdCascadeBach->GetD(esd.GetPrimaryVertex()->GetX(),\r
 714                                                                      esd.GetPrimaryVertex()->GetY(),\r
 715                                                                      esd.GetMagneticField())        );\r
 716     \r
 717     Double_t momBachAtCascadeVtx[3]={0.};\r
 718 \r
 719     esdCascade->GetBPxPyPz(momBachAtCascadeVtx[0], momBachAtCascadeVtx[1], momBachAtCascadeVtx[2]);\r
 720     \r
 721     aodCascade = new(cascadesArray[fNumberOfCascades++]) AliAODcascade(  vCascade,\r
 722                                                           esdCascade->Charge(),\r
 723                                                           esdCascade->GetDcaXiDaughters(),\r
 724                                                           -999.,\r
 725                                                           // DCAXiToPrimVtx -> needs to be calculated   ----|\r
 726                                                           // doesn't exist at ESD level;\r
 727                                                           // See AODcascade::DcaXiToPrimVertex(Double, Double, Double)\r
 728                                                           dcaBachToPrimVertexXY,\r
 729                                                           momBachAtCascadeVtx,\r
 730                                                           *aodV0);\r
 731     \r
 732     if (fDebug > 10) {\r
 733       printf("---- Cascade / AOD cascade : \n\n");\r
 734       aodCascade->PrintXi(fPrimaryVertex->GetX(), fPrimaryVertex->GetY(), fPrimaryVertex->GetZ());\r
 735     }\r
 736     \r
 737   } // end of the loop on cascades\r
 738   \r
 739   Cascades().Expand(fNumberOfCascades);\r
 740 }\r
 741 \r
 742 //______________________________________________________________________________\r
 743 void AliAnalysisTaskESDfilter::ConvertV0s(const AliESDEvent& esd)\r
 744 {\r
 745   // Access to the AOD container of V0s\r
 746   \r
 747   AliCodeTimerAuto("",0);\r
 748 \r
 749   //\r
 750   // V0s\r
 751   //\r
 752   \r
 753   Double_t pos[3] = { 0. };      \r
 754   Double_t chi2(0.0);\r
 755   Double_t covVtx[6] = { 0. };\r
 756   Double_t momPos[3]={0.};\r
 757   Double_t covTr[21]={0.};\r
 758   Double_t pid[10]={0.};\r
 759   AliAODTrack* aodTrack(0x0);\r
 760   AliAODPid* detpid(0x0);\r
 761   Double_t momNeg[3]={0.};\r
 762   Double_t momPosAtV0vtx[3]={0.};\r
 763   Double_t momNegAtV0vtx[3]={0.};\r
 764     \r
 765   for (Int_t nV0 = 0; nV0 < esd.GetNumberOfV0s(); ++nV0) \r
 766   {\r
 767     if (fUsedV0[nV0]) continue; // skip if already added to the AOD\r
 768     \r
 769     AliESDv0 *v0 = esd.GetV0(nV0);\r
 770     Int_t posFromV0 = v0->GetPindex();\r
 771     Int_t negFromV0 = v0->GetNindex();\r
 772     \r
 773     // V0 selection \r
 774     //\r
 775     AliESDVertex *esdVtx   = new AliESDVertex(*(esd.GetPrimaryVertex()));\r
 776     AliESDtrack  *esdV0Pos = esd.GetTrack(posFromV0);\r
 777     AliESDtrack  *esdV0Neg = esd.GetTrack(negFromV0);\r
 778     TList v0objects;\r
 779     v0objects.AddAt(v0,                      0);\r
 780     v0objects.AddAt(esdV0Pos,                1);\r
 781     v0objects.AddAt(esdV0Neg,                2);\r
 782     v0objects.AddAt(esdVtx,                  3);\r
 783     UInt_t selectV0 = 0;\r
 784     if (fV0Filter) {\r
 785       selectV0 = fV0Filter->IsSelected(&v0objects);\r
 786       // this is a little awkward but otherwise the \r
 787       // list wants to access the pointer (delete it) \r
 788       // again when going out of scope\r
 789       delete v0objects.RemoveAt(3); // esdVtx created via copy construct\r
 790       esdVtx = 0;\r
 791       if (!selectV0) \r
 792         continue;\r
 793     }\r
 794     else{\r
 795       delete v0objects.RemoveAt(3); // esdVtx created via copy construct\r
 796       esdVtx = 0;\r
 797     }\r
 798     \r
 799     v0->GetXYZ(pos[0], pos[1], pos[2]);\r
 800     \r
 801     if (!fOldESDformat) {\r
 802             chi2 = v0->GetChi2V0(); // = chi2/NDF since NDF = 2*2-3\r
 803             v0->GetPosCov(covVtx);\r
 804     } else {\r
 805             chi2 = -999.;\r
 806             for (Int_t i = 0; i < 6; i++)  covVtx[i] = 0.;\r
 807     }\r
 808     \r
 809     \r
 810     AliAODVertex * vV0 = \r
 811           new(Vertices()[fNumberOfVertices++]) AliAODVertex(pos,\r
 812                                                       covVtx,\r
 813                                                       chi2,\r
 814                                                       fPrimaryVertex,\r
 815                                                       nV0,\r
 816                                                       AliAODVertex::kV0);\r
 817     fPrimaryVertex->AddDaughter(vV0);\r
 818     \r
 819     \r
 820     // Add the positive tracks from the V0\r
 821     \r
 822 \r
 823     esdV0Pos->GetPxPyPz(momPos);\r
 824     esdV0Pos->GetXYZ(pos);\r
 825     esdV0Pos->GetCovarianceXYZPxPyPz(covTr);\r
 826     esdV0Pos->GetESDpid(pid);\r
 827     \r
 828     const AliESDVertex *vtx = esd.GetPrimaryVertex();\r
 829 \r
 830     if (!fUsedTrack[posFromV0]) {\r
 831             fUsedTrack[posFromV0] = kTRUE;\r
 832             UInt_t selectInfo = 0;\r
 833             if (fTrackFilter) selectInfo = fTrackFilter->IsSelected(esdV0Pos);\r
 834             if(fMChandler)fMChandler->SelectParticle(esdV0Pos->GetLabel());\r
 835             aodTrack = new(Tracks()[fNumberOfTracks++]) AliAODTrack(esdV0Pos->GetID(),\r
 836                                                     esdV0Pos->GetLabel(), \r
 837                                                     momPos, \r
 838                                                     kTRUE,\r
 839                                                     pos,\r
 840                                                     kFALSE,\r
 841                                                     covTr, \r
 842                                                     (Short_t)esdV0Pos->GetSign(),\r
 843                                                     esdV0Pos->GetITSClusterMap(), \r
 844                                                     pid,\r
 845                                                     vV0,\r
 846                                                     kTRUE,  // check if this is right\r
 847                                                     vtx->UsesTrack(esdV0Pos->GetID()),\r
 848                                                     AliAODTrack::kSecondary,\r
 849                                                     selectInfo);\r
 850             aodTrack->SetTPCClusterMap(esdV0Pos->GetTPCClusterMap());\r
 851             aodTrack->SetTPCSharedMap (esdV0Pos->GetTPCSharedMap());\r
 852             aodTrack->SetChi2perNDF(Chi2perNDF(esdV0Pos));\r
 853             aodTrack->SetTPCPointsF(esdV0Pos->GetTPCNclsF());\r
 854             fAODTrackRefs->AddAt(aodTrack,posFromV0);\r
 855             //      if (fDebug > 0) printf("-------------------Bo: pos track from original pt %.3f \n",aodTrack->Pt());\r
 856             if (esdV0Pos->GetSign() > 0) ++fNumberOfPositiveTracks;\r
 857             aodTrack->ConvertAliPIDtoAODPID();\r
 858             aodTrack->SetFlags(esdV0Pos->GetStatus());\r
 859       SetAODPID(esdV0Pos,aodTrack,detpid);\r
 860     }\r
 861     else {\r
 862             aodTrack = static_cast<AliAODTrack*>(fAODTrackRefs->At(posFromV0));\r
 863             //      if (fDebug > 0) printf("-------------------Bo pos track from refArray pt %.3f \n",aodTrack->Pt());\r
 864     }\r
 865     vV0->AddDaughter(aodTrack);\r
 866     \r
 867     // Add the negative tracks from the V0\r
 868     \r
 869     esdV0Neg->GetPxPyPz(momNeg);\r
 870     esdV0Neg->GetXYZ(pos);\r
 871     esdV0Neg->GetCovarianceXYZPxPyPz(covTr);\r
 872     esdV0Neg->GetESDpid(pid);\r
 873     \r
 874     if (!fUsedTrack[negFromV0]) {\r
 875             fUsedTrack[negFromV0] = kTRUE;\r
 876             UInt_t selectInfo = 0;\r
 877             if (fTrackFilter) selectInfo = fTrackFilter->IsSelected(esdV0Neg);\r
 878             if(fMChandler)fMChandler->SelectParticle(esdV0Neg->GetLabel());\r
 879             aodTrack = new(Tracks()[fNumberOfTracks++]) AliAODTrack(esdV0Neg->GetID(),\r
 880                                                     esdV0Neg->GetLabel(),\r
 881                                                     momNeg,\r
 882                                                     kTRUE,\r
 883                                                     pos,\r
 884                                                     kFALSE,\r
 885                                                     covTr, \r
 886                                                     (Short_t)esdV0Neg->GetSign(),\r
 887                                                     esdV0Neg->GetITSClusterMap(), \r
 888                                                     pid,\r
 889                                                     vV0,\r
 890                                                     kTRUE,  // check if this is right\r
 891                                                     vtx->UsesTrack(esdV0Neg->GetID()),\r
 892                                                     AliAODTrack::kSecondary,\r
 893                                                     selectInfo);\r
 894             aodTrack->SetTPCClusterMap(esdV0Neg->GetTPCClusterMap());\r
 895             aodTrack->SetTPCSharedMap (esdV0Neg->GetTPCSharedMap());\r
 896             aodTrack->SetChi2perNDF(Chi2perNDF(esdV0Neg));\r
 897             aodTrack->SetTPCPointsF(esdV0Neg->GetTPCNclsF());\r
 898             \r
 899             fAODTrackRefs->AddAt(aodTrack,negFromV0);\r
 900             //      if (fDebug > 0) printf("-------------------Bo: neg track from original pt %.3f \n",aodTrack->Pt());\r
 901             if (esdV0Neg->GetSign() > 0) ++fNumberOfPositiveTracks;\r
 902             aodTrack->ConvertAliPIDtoAODPID();\r
 903             aodTrack->SetFlags(esdV0Neg->GetStatus());\r
 904       SetAODPID(esdV0Neg,aodTrack,detpid);\r
 905     }\r
 906     else {\r
 907             aodTrack = static_cast<AliAODTrack*>(fAODTrackRefs->At(negFromV0));\r
 908             //      if (fDebug > 0) printf("-------------------Bo neg track from refArray pt %.3f \n",aodTrack->Pt());\r
 909     }\r
 910     vV0->AddDaughter(aodTrack);\r
 911     \r
 912     \r
 913     // Add the V0 the V0 array as well\r
 914     \r
 915     Double_t  dcaV0Daughters      = v0->GetDcaV0Daughters();\r
 916     Double_t  dcaV0ToPrimVertex   = v0->GetD(esd.GetPrimaryVertex()->GetX(),\r
 917                                              esd.GetPrimaryVertex()->GetY(),\r
 918                                              esd.GetPrimaryVertex()->GetZ());\r
 919     \r
 920     v0->GetPPxPyPz(momPosAtV0vtx[0],momPosAtV0vtx[1],momPosAtV0vtx[2]); \r
 921     v0->GetNPxPyPz(momNegAtV0vtx[0],momNegAtV0vtx[1],momNegAtV0vtx[2]); \r
 922     \r
 923     Double_t dcaDaughterToPrimVertex[2] = { 999., 999.}; // ..[0] = DCA in (x,y) for Pos and ..[1] = Neg\r
 924     dcaDaughterToPrimVertex[0] = TMath::Abs(esdV0Pos->GetD(  esd.GetPrimaryVertex()->GetX(),\r
 925                                                            esd.GetPrimaryVertex()->GetY(),\r
 926                                                            esd.GetMagneticField()) );\r
 927     dcaDaughterToPrimVertex[1] = TMath::Abs(esdV0Neg->GetD(  esd.GetPrimaryVertex()->GetX(),\r
 928                                                            esd.GetPrimaryVertex()->GetY(),\r
 929                                                            esd.GetMagneticField()) );\r
 930     \r
 931     AliAODv0* aodV0 = new(V0s()[fNumberOfV0s++]) AliAODv0(vV0, \r
 932                                                 dcaV0Daughters,\r
 933                                                 dcaV0ToPrimVertex,\r
 934                                                 momPosAtV0vtx,\r
 935                                                 momNegAtV0vtx,\r
 936                                                 dcaDaughterToPrimVertex);\r
 937     \r
 938     // set the aod v0 on-the-fly status\r
 939     aodV0->SetOnFlyStatus(v0->GetOnFlyStatus());\r
 940   }//End of loop on V0s \r
 941   \r
 942   V0s().Expand(fNumberOfV0s);    \r
 943 }\r
 944 \r
 945 //______________________________________________________________________________\r
 946 void AliAnalysisTaskESDfilter::ConvertTPCOnlyTracks(const AliESDEvent& esd)\r
 947 {\r
 948   // Convert TPC only tracks\r
 949   // Here we have wo hybrid appraoch to remove fakes\r
 950   // ******* ITSTPC ********\r
 951   // Uses a cut on the ITS properties to select global tracks\r
 952   // which are than marked as HybdridITSTPC for the remainder the TPC only tracks are \r
 953   // flagged as HybridITSTPConly. Note, in order not to get fakes back in the TPC cuts, one needs \r
 954   // two "ITS" cuts one tight (1) (to throw out fakes) and one lose (2) (to NOT flag the trakcs in the TPC only)\r
 955   // using cut number (3)\r
 956   // so fHybridFilterMask == (1)|(2) fTPCFilterMask = (3), Usercode needs to slect with mask = (1)|(3) and track->IsHybridITSTPC()\r
 957   // ******* TPC ********\r
 958   // Here, only TPC tracks are flagged that pass the tight ITS cuts and tracks that pass the TPC cuts and NOT the loose ITS cuts\r
 959   // the ITS cuts neeed to be added to the filter as extra cuts, since here the selections info is reset in the global and put to the TPC only track\r
 960 \r
 961   AliCodeTimerAuto("",0);\r
 962   \r
 963   // Loop over the tracks and extract and mask out all aod tracks that pass the selections for AODt racks\r
 964   for(int it = 0;it < fNumberOfTracks;++it)\r
 965   {\r
 966     AliAODTrack *tr = (AliAODTrack*)(Tracks().At(it));\r
 967     if(!tr)continue;\r
 968     UInt_t map = tr->GetFilterMap();\r
 969     if(map&fTPCOnlyFilterMask){\r
 970       // we only reset the track select ionfo, no deletion...\r
 971       tr->SetFilterMap(map&~fTPCOnlyFilterMask);\r
 972     }\r
 973     if(map&fHybridFilterMaskITSTPC){\r
 974       // this is one part of the hybrid tracks\r
 975       // the others not passing the selection will be TPC only selected below\r
 976       tr->SetIsHybridITSTPC(kTRUE);\r
 977     }\r
 978   }\r
 979   // Loop over the ESD trcks and pick out the tracks passing TPC only cuts\r
 980   \r
 981   \r
 982   const AliESDVertex *vtxSPD = esd.GetPrimaryVertexSPD();\r
 983   const AliESDVertex *vtx = esd.GetPrimaryVertex();\r
 984 \r
 985   Double_t pos[3] = { 0. };      \r
 986   Double_t covTr[21]={0.};\r
 987   Double_t pid[10]={0.};  \r
 988   Double_t p[3] = { 0. };\r
 989 \r
 990   Double_t pDCA[3] = { 0. }; // momentum at DCA\r
 991   Double_t rDCA[3] = { 0. }; // position at DCA\r
 992   Float_t  dDCA[2] = {0.};    // DCA to the vertex d and z\r
 993   Float_t  cDCA[3] = {0.};    // covariance of impact parameters\r
 994 \r
 995 \r
 996   AliAODTrack* aodTrack(0x0);\r
 997   \r
 998   for (Int_t nTrack = 0; nTrack < esd.GetNumberOfTracks(); ++nTrack) \r
 999   {\r
1000     AliESDtrack* esdTrack = esd.GetTrack(nTrack); //carefull do not modify it othwise  need to work with a copy \r
1001     \r
1002     UInt_t selectInfo = 0;\r
1003     Bool_t isHybridITSTPC = false;\r
1004     Bool_t isHybridTPC = false;\r
1005     //\r
1006     // Track selection\r
1007     if (fTrackFilter) {\r
1008       selectInfo = fTrackFilter->IsSelected(esdTrack);\r
1009     }\r
1010 \r
1011     if(!(selectInfo&fHybridFilterMaskITSTPC)){\r
1012       // not already selected tracks, use second part of hybrid tracks\r
1013       isHybridITSTPC = true;\r
1014       // too save space one could only store these...\r
1015     }\r
1016 \r
1017     if(selectInfo&fHybridFilterMaskTPC0){\r
1018       isHybridTPC = true;\r
1019     }\r
1020     else if (!(selectInfo&fHybridFilterMaskTPC1)){\r
1021       // select all that have not been chosen by the loose \r
1022       // cuts\r
1023       isHybridTPC = true;\r
1024     }\r
1025 \r
1026 \r
1027     selectInfo &= fTPCOnlyFilterMask;\r
1028     if (!selectInfo)continue;\r
1029     \r
1030     // create a tpc only tracl\r
1031     AliESDtrack *track = AliESDtrackCuts::GetTPCOnlyTrack(const_cast<AliESDEvent*>(&esd),esdTrack->GetID());\r
1032     if(!track) continue;\r
1033     \r
1034     if(track->Pt()>0.)\r
1035     {\r
1036       // only constrain tracks above threshold\r
1037       AliExternalTrackParam exParam;\r
1038       // take the B-field from the ESD, no 3D fieldMap available at this point\r
1039       Bool_t relate = false;\r
1040       relate = track->RelateToVertexTPC(vtxSPD,esd.GetMagneticField(),kVeryBig,&exParam);\r
1041       if(!relate){\r
1042         delete track;\r
1043         continue;\r
1044       }\r
1045       // fetch the track parameters at the DCA (unconstraint)\r
1046       if(track->GetTPCInnerParam()){\r
1047         track->GetTPCInnerParam()->GetPxPyPz(pDCA);\r
1048         track->GetTPCInnerParam()->GetXYZ(rDCA);\r
1049       }\r
1050       // get the DCA to the vertex:\r
1051       track->GetImpactParametersTPC(dDCA,cDCA);\r
1052       // set the constraint parameters to the track\r
1053       track->Set(exParam.GetX(),exParam.GetAlpha(),exParam.GetParameter(),exParam.GetCovariance());\r
1054     }\r
1055     \r
1056     track->GetPxPyPz(p);\r
1057     track->GetXYZ(pos);\r
1058     track->GetCovarianceXYZPxPyPz(covTr);\r
1059     track->GetESDpid(pid);\r
1060     if(fMChandler)fMChandler->SelectParticle(esdTrack->GetLabel());\r
1061     aodTrack = new(Tracks()[fNumberOfTracks++]) AliAODTrack((track->GetID()+1)*-1,\r
1062                                                             track->GetLabel(),\r
1063                                                             p,\r
1064                                                             kTRUE,\r
1065                                                             pos,\r
1066                                                             kFALSE,\r
1067                                                             covTr, \r
1068                                                             (Short_t)track->GetSign(),\r
1069                                                             track->GetITSClusterMap(), \r
1070                                                             pid,\r
1071                                                             fPrimaryVertex,\r
1072                                                             kTRUE, // check if this is right\r
1073                                                             vtx->UsesTrack(track->GetID()),\r
1074                                                             AliAODTrack::kPrimary, \r
1075                                                             selectInfo);\r
1076     aodTrack->SetIsHybridITSTPC(isHybridITSTPC);    \r
1077     aodTrack->SetIsHybridTPC(isHybridTPC);\r
1078     aodTrack->SetTPCClusterMap(track->GetTPCClusterMap());\r
1079     aodTrack->SetTPCSharedMap (track->GetTPCSharedMap());\r
1080     Float_t ndf = track->GetTPCNcls()+1 - 5 ;\r
1081     if(ndf>0){\r
1082       aodTrack->SetChi2perNDF(track->GetConstrainedChi2TPC());\r
1083     }\r
1084     else{\r
1085       aodTrack->SetChi2perNDF(-1);\r
1086     }\r
1087 \r
1088     // set the DCA values to the AOD track\r
1089     aodTrack->SetPxPyPzAtDCA(pDCA[0],pDCA[1],pDCA[2]);\r
1090     aodTrack->SetXYAtDCA(rDCA[0],rDCA[1]);\r
1091     aodTrack->SetDCA(dDCA[0],dDCA[1]);\r
1092 \r
1093     aodTrack->SetFlags(track->GetStatus());\r
1094     aodTrack->SetTPCPointsF(track->GetTPCNclsF());\r
1095 \r
1096     delete track;\r
1097   } // end of loop on tracks\r
1098   \r
1099 }\r
1100 \r
1101 //______________________________________________________________________________\r
1102 void AliAnalysisTaskESDfilter::ConvertTracks(const AliESDEvent& esd)\r
1103 {\r
1104   // Tracks (primary and orphan)\r
1105 \r
1106   AliCodeTimerAuto("",0);\r
1107   \r
1108   AliDebug(1,Form("NUMBER OF ESD TRACKS %5d\n", esd.GetNumberOfTracks()));\r
1109   \r
1110   const AliESDVertex *vtx = esd.GetPrimaryVertex();\r
1111   Double_t p[3] = { 0. };\r
1112   Double_t pos[3] = { 0. };\r
1113   Double_t covTr[21] = { 0. };\r
1114   Double_t pid[10] = { 0. };\r
1115   AliAODTrack* aodTrack(0x0);\r
1116   AliAODPid* detpid(0x0);\r
1117   \r
1118   for (Int_t nTrack = 0; nTrack < esd.GetNumberOfTracks(); ++nTrack) \r
1119   {\r
1120     if (fUsedTrack[nTrack]) continue;\r
1121     \r
1122     AliESDtrack *esdTrack = esd.GetTrack(nTrack);\r
1123     UInt_t selectInfo = 0;\r
1124     //\r
1125     // Track selection\r
1126     if (fTrackFilter) {\r
1127             selectInfo = fTrackFilter->IsSelected(esdTrack);\r
1128             if (!selectInfo && !vtx->UsesTrack(esdTrack->GetID())) continue;\r
1129     }\r
1130     \r
1131     \r
1132     esdTrack->GetPxPyPz(p);\r
1133     esdTrack->GetXYZ(pos);\r
1134     esdTrack->GetCovarianceXYZPxPyPz(covTr);\r
1135     esdTrack->GetESDpid(pid);\r
1136     if(fMChandler)fMChandler->SelectParticle(esdTrack->GetLabel());\r
1137     fPrimaryVertex->AddDaughter(aodTrack =\r
1138                          new(Tracks()[fNumberOfTracks++]) AliAODTrack(esdTrack->GetID(),\r
1139                                                             esdTrack->GetLabel(),\r
1140                                                             p,\r
1141                                                             kTRUE,\r
1142                                                             pos,\r
1143                                                             kFALSE,\r
1144                                                             covTr, \r
1145                                                             (Short_t)esdTrack->GetSign(),\r
1146                                                             esdTrack->GetITSClusterMap(), \r
1147                                                             pid,\r
1148                                                             fPrimaryVertex,\r
1149                                                             kTRUE, // check if this is right\r
1150                                                             vtx->UsesTrack(esdTrack->GetID()),\r
1151                                                             AliAODTrack::kPrimary, \r
1152                                                             selectInfo)\r
1153                          );\r
1154     aodTrack->SetTPCClusterMap(esdTrack->GetTPCClusterMap());\r
1155     aodTrack->SetTPCSharedMap (esdTrack->GetTPCSharedMap());\r
1156     aodTrack->SetChi2perNDF(Chi2perNDF(esdTrack));\r
1157     aodTrack->SetTPCPointsF(esdTrack->GetTPCNclsF());\r
1158 \r
1159     fAODTrackRefs->AddAt(aodTrack, nTrack);\r
1160     \r
1161     \r
1162     if (esdTrack->GetSign() > 0) ++fNumberOfPositiveTracks;\r
1163     aodTrack->SetFlags(esdTrack->GetStatus());\r
1164     aodTrack->ConvertAliPIDtoAODPID();\r
1165     SetAODPID(esdTrack,aodTrack,detpid);\r
1166   } // end of loop on tracks\r
1167 }\r
1168 \r
1169 //______________________________________________________________________________\r
1170 void AliAnalysisTaskESDfilter::ConvertPmdClusters(const AliESDEvent& esd)\r
1171 {\r
1172   AliCodeTimerAuto("",0);\r
1173   Int_t jPmdClusters=0;\r
1174   // Access to the AOD container of PMD clusters\r
1175   TClonesArray &pmdClusters = *(AODEvent()->GetPmdClusters());\r
1176   for (Int_t iPmd = 0; iPmd < esd.GetNumberOfPmdTracks(); ++iPmd) {\r
1177     // file pmd clusters, to be revised!\r
1178     AliESDPmdTrack *pmdTrack = esd.GetPmdTrack(iPmd);\r
1179     Int_t nLabel = 0;\r
1180     Int_t *label = 0x0;\r
1181     Double_t posPmd[3] = { pmdTrack->GetClusterX(), pmdTrack->GetClusterY(), pmdTrack->GetClusterZ()};\r
1182     Double_t pidPmd[13] = { 0.}; // to be revised!\r
1183     // type not set!\r
1184     // assoc cluster not set\r
1185     new(pmdClusters[jPmdClusters++]) AliAODPmdCluster(iPmd, nLabel, label, pmdTrack->GetClusterADC(), posPmd, pidPmd);\r
1186   }\r
1187 }\r
1188 \r
1189 //______________________________________________________________________________\r
1190 void AliAnalysisTaskESDfilter::ConvertCaloClusters(const AliESDEvent& esd)\r
1191 {\r
1192   AliCodeTimerAuto("",0);\r
1193   \r
1194   // Access to the AOD container of clusters\r
1195   TClonesArray &caloClusters = *(AODEvent()->GetCaloClusters());\r
1196   Int_t jClusters(0);\r
1197   \r
1198   for (Int_t iClust=0; iClust<esd.GetNumberOfCaloClusters(); ++iClust) {\r
1199     \r
1200     AliESDCaloCluster * cluster = esd.GetCaloCluster(iClust);\r
1201     \r
1202     Int_t  id        = cluster->GetID();\r
1203     Int_t  nLabel    = cluster->GetNLabels();\r
1204     Int_t *labels    = cluster->GetLabels();\r
1205     if(labels){ \r
1206                   for(int i = 0;i < nLabel;++i){\r
1207                           if(fMChandler)fMChandler->SelectParticle(labels[i]);\r
1208                   }\r
1209           }             \r
1210     \r
1211     Float_t energy = cluster->E();\r
1212     Float_t posF[3] = { 0.};\r
1213     cluster->GetPosition(posF);\r
1214     \r
1215     AliAODCaloCluster *caloCluster = new(caloClusters[jClusters++]) AliAODCaloCluster(id,\r
1216                                                                                       nLabel,\r
1217                                                                                       labels,\r
1218                                                                                       energy,\r
1219                                                                                       posF,\r
1220                                                                                       NULL,\r
1221                                                                                       cluster->GetType(),0);\r
1222     \r
1223     caloCluster->SetCaloCluster(cluster->GetDistanceToBadChannel(),\r
1224                                 cluster->GetDispersion(),\r
1225                                 cluster->GetM20(), cluster->GetM02(),\r
1226                                 cluster->GetEmcCpvDistance(),  \r
1227                                 cluster->GetNExMax(),cluster->GetTOF()) ;\r
1228     \r
1229     caloCluster->SetPIDFromESD(cluster->GetPID());\r
1230     caloCluster->SetNCells(cluster->GetNCells());\r
1231     caloCluster->SetCellsAbsId(cluster->GetCellsAbsId());\r
1232     caloCluster->SetCellsAmplitudeFraction(cluster->GetCellsAmplitudeFraction());\r
1233     \r
1234     TArrayI* matchedT =         cluster->GetTracksMatched();\r
1235     if (fNumberOfTracks>0 && matchedT && cluster->GetTrackMatchedIndex() >= 0) {        \r
1236       for (Int_t im = 0; im < matchedT->GetSize(); im++) {\r
1237         Int_t iESDtrack = matchedT->At(im);;\r
1238         if (fAODTrackRefs->At(iESDtrack) != 0) {\r
1239           caloCluster->AddTrackMatched((AliAODTrack*)fAODTrackRefs->At(iESDtrack));\r
1240         }\r
1241       }\r
1242     }\r
1243     \r
1244   } \r
1245   caloClusters.Expand(jClusters); // resize TObjArray to 'remove' slots for pseudo clusters      \r
1246 }\r
1247 \r
1248 //______________________________________________________________________________\r
1249 void AliAnalysisTaskESDfilter::ConvertEMCALCells(const AliESDEvent& esd)\r
1250 {\r
1251   AliCodeTimerAuto("",0);\r
1252   // fill EMCAL cell info\r
1253   if (esd.GetEMCALCells()) { // protection against missing ESD information\r
1254     AliESDCaloCells &esdEMcells = *(esd.GetEMCALCells());\r
1255     Int_t nEMcell = esdEMcells.GetNumberOfCells() ;\r
1256     \r
1257     AliAODCaloCells &aodEMcells = *(AODEvent()->GetEMCALCells());\r
1258     aodEMcells.CreateContainer(nEMcell);\r
1259     aodEMcells.SetType(AliAODCaloCells::kEMCALCell);\r
1260     for (Int_t iCell = 0; iCell < nEMcell; iCell++) {      \r
1261       aodEMcells.SetCell(iCell,esdEMcells.GetCellNumber(iCell),esdEMcells.GetAmplitude(iCell));\r
1262     }\r
1263     aodEMcells.Sort();\r
1264   }\r
1265 }\r
1266 \r
1267 //______________________________________________________________________________\r
1268 void AliAnalysisTaskESDfilter::ConvertPHOSCells(const AliESDEvent& esd)\r
1269 {\r
1270   AliCodeTimerAuto("",0);\r
1271   // fill PHOS cell info\r
1272   if (esd.GetPHOSCells()) { // protection against missing ESD information\r
1273     AliESDCaloCells &esdPHcells = *(esd.GetPHOSCells());\r
1274     Int_t nPHcell = esdPHcells.GetNumberOfCells() ;\r
1275     \r
1276     AliAODCaloCells &aodPHcells = *(AODEvent()->GetPHOSCells());\r
1277     aodPHcells.CreateContainer(nPHcell);\r
1278     aodPHcells.SetType(AliAODCaloCells::kPHOSCell);\r
1279     for (Int_t iCell = 0; iCell < nPHcell; iCell++) {      \r
1280       aodPHcells.SetCell(iCell,esdPHcells.GetCellNumber(iCell),esdPHcells.GetAmplitude(iCell));\r
1281     }\r
1282     aodPHcells.Sort();\r
1283   }\r
1284 }\r
1285 \r
1286 //______________________________________________________________________________\r
1287 void AliAnalysisTaskESDfilter::ConvertTracklets(const AliESDEvent& esd)\r
1288 {\r
1289   // tracklets    \r
1290   AliCodeTimerAuto("",0);\r
1291 \r
1292   AliAODTracklets &SPDTracklets = *(AODEvent()->GetTracklets());\r
1293   const AliMultiplicity *mult = esd.GetMultiplicity();\r
1294   if (mult) {\r
1295     if (mult->GetNumberOfTracklets()>0) {\r
1296       SPDTracklets.CreateContainer(mult->GetNumberOfTracklets());\r
1297       \r
1298       for (Int_t n=0; n<mult->GetNumberOfTracklets(); n++) {\r
1299         if(fMChandler){\r
1300           fMChandler->SelectParticle(mult->GetLabel(n, 0));\r
1301           fMChandler->SelectParticle(mult->GetLabel(n, 1));\r
1302         }\r
1303         SPDTracklets.SetTracklet(n, mult->GetTheta(n), mult->GetPhi(n), mult->GetDeltaPhi(n), mult->GetLabel(n, 0),mult->GetLabel(n, 1));\r
1304       }\r
1305     }\r
1306   } else {\r
1307     //Printf("ERROR: AliMultiplicity could not be retrieved from ESD");\r
1308   }\r
1309 }\r
1310 \r
1311 //______________________________________________________________________________\r
1312 void AliAnalysisTaskESDfilter::ConvertKinks(const AliESDEvent& esd)\r
1313 {\r
1314   AliCodeTimerAuto("",0);\r
1315   \r
1316   // Kinks: it is a big mess the access to the information in the kinks\r
1317   // The loop is on the tracks in order to find the mother and daugther of each kink\r
1318   \r
1319   Double_t covTr[21]={0.};\r
1320   Double_t pid[10]={0.};\r
1321   AliAODPid* detpid(0x0);\r
1322   \r
1323   fNumberOfKinks = esd.GetNumberOfKinks();\r
1324 \r
1325   const AliESDVertex* vtx = esd.GetPrimaryVertex();\r
1326   \r
1327   for (Int_t iTrack=0; iTrack<esd.GetNumberOfTracks(); ++iTrack) \r
1328   {\r
1329     AliESDtrack * esdTrack = esd.GetTrack(iTrack);\r
1330     \r
1331     Int_t ikink = esdTrack->GetKinkIndex(0);\r
1332     \r
1333     if (ikink && fNumberOfKinks) {\r
1334             // Negative kink index: mother, positive: daughter\r
1335             \r
1336             // Search for the second track of the kink\r
1337             \r
1338             for (Int_t jTrack = iTrack+1; jTrack<esd.GetNumberOfTracks(); ++jTrack) {\r
1339         \r
1340         AliESDtrack * esdTrack1 = esd.GetTrack(jTrack);\r
1341         \r
1342         Int_t jkink = esdTrack1->GetKinkIndex(0);\r
1343         \r
1344         if ( TMath::Abs(ikink)==TMath::Abs(jkink) ) {\r
1345           \r
1346           // The two tracks are from the same kink\r
1347           \r
1348           if (fUsedKink[TMath::Abs(ikink)-1]) continue; // skip used kinks\r
1349           \r
1350           Int_t imother = -1;\r
1351           Int_t idaughter = -1;\r
1352           \r
1353           if (ikink<0 && jkink>0) {\r
1354             \r
1355             imother = iTrack;\r
1356             idaughter = jTrack;\r
1357           }\r
1358           else if (ikink>0 && jkink<0) {\r
1359             \r
1360             imother = jTrack;\r
1361             idaughter = iTrack;\r
1362           }\r
1363           else {\r
1364             //                  cerr << "Error: Wrong combination of kink indexes: "\r
1365             //                       << ikink << " " << jkink << endl;\r
1366             continue;\r
1367           }\r
1368           \r
1369           // Add the mother track if it passed primary track selection cuts\r
1370           \r
1371           AliAODTrack * mother = NULL;\r
1372           \r
1373           UInt_t selectInfo = 0;\r
1374           if (fTrackFilter) {\r
1375             selectInfo = fTrackFilter->IsSelected(esd.GetTrack(imother));\r
1376             if (!selectInfo) continue;\r
1377           }\r
1378           \r
1379           if (!fUsedTrack[imother]) {\r
1380             \r
1381             fUsedTrack[imother] = kTRUE;\r
1382             \r
1383             AliESDtrack *esdTrackM = esd.GetTrack(imother);\r
1384             Double_t p[3] = { 0. };\r
1385             Double_t pos[3] = { 0. };\r
1386             esdTrackM->GetPxPyPz(p);\r
1387             esdTrackM->GetXYZ(pos);\r
1388             esdTrackM->GetCovarianceXYZPxPyPz(covTr);\r
1389             esdTrackM->GetESDpid(pid);\r
1390             if(fMChandler)fMChandler->SelectParticle(esdTrackM->GetLabel());\r
1391             mother = \r
1392             new(Tracks()[fNumberOfTracks++]) AliAODTrack(esdTrackM->GetID(),\r
1393                                                esdTrackM->GetLabel(),\r
1394                                                p,\r
1395                                                kTRUE,\r
1396                                                pos,\r
1397                                                kFALSE,\r
1398                                                covTr, \r
1399                                                (Short_t)esdTrackM->GetSign(),\r
1400                                                esdTrackM->GetITSClusterMap(), \r
1401                                                pid,\r
1402                                                fPrimaryVertex,\r
1403                                                kTRUE, // check if this is right\r
1404                                                vtx->UsesTrack(esdTrack->GetID()),\r
1405                                                AliAODTrack::kPrimary,\r
1406                                                selectInfo);\r
1407             mother->SetTPCClusterMap(esdTrackM->GetTPCClusterMap());\r
1408             mother->SetTPCSharedMap (esdTrackM->GetTPCSharedMap());\r
1409             mother->SetChi2perNDF(Chi2perNDF(esdTrackM));\r
1410             mother->SetTPCPointsF(esdTrackM->GetTPCNclsF());\r
1411 \r
1412             fAODTrackRefs->AddAt(mother, imother);\r
1413             \r
1414             if (esdTrackM->GetSign() > 0) ++fNumberOfPositiveTracks;\r
1415             mother->SetFlags(esdTrackM->GetStatus());\r
1416             mother->ConvertAliPIDtoAODPID();\r
1417             fPrimaryVertex->AddDaughter(mother);\r
1418             mother->ConvertAliPIDtoAODPID();\r
1419             SetAODPID(esdTrackM,mother,detpid);\r
1420           }\r
1421           else {\r
1422             //                  cerr << "Error: event " << esd.GetEventNumberInFile() << " kink " << TMath::Abs(ikink)-1\r
1423             //                       << " track " << imother << " has already been used!" << endl;\r
1424           }\r
1425           \r
1426           // Add the kink vertex\r
1427           AliESDkink * kink = esd.GetKink(TMath::Abs(ikink)-1);\r
1428           \r
1429           AliAODVertex * vkink = \r
1430           new(Vertices()[fNumberOfVertices++]) AliAODVertex(kink->GetPosition(),\r
1431                                                   NULL,\r
1432                                                   0.,\r
1433                                                   mother,\r
1434                                                   esdTrack->GetID(),  // This is the track ID of the mother's track!\r
1435                                                   AliAODVertex::kKink);\r
1436           // Add the daughter track\r
1437           \r
1438           AliAODTrack * daughter = NULL;\r
1439           \r
1440           if (!fUsedTrack[idaughter]) {\r
1441             \r
1442             fUsedTrack[idaughter] = kTRUE;\r
1443             \r
1444             AliESDtrack *esdTrackD = esd.GetTrack(idaughter);\r
1445             Double_t p[3] = { 0. };\r
1446             Double_t pos[3] = { 0. };\r
1447 \r
1448             esdTrackD->GetPxPyPz(p);\r
1449             esdTrackD->GetXYZ(pos);\r
1450             esdTrackD->GetCovarianceXYZPxPyPz(covTr);\r
1451             esdTrackD->GetESDpid(pid);\r
1452             selectInfo = 0;\r
1453             if (fTrackFilter) selectInfo = fTrackFilter->IsSelected(esdTrackD);\r
1454             if(fMChandler)fMChandler->SelectParticle(esdTrackD->GetLabel());\r
1455             daughter = \r
1456             new(Tracks()[fNumberOfTracks++]) AliAODTrack(esdTrackD->GetID(),\r
1457                                                esdTrackD->GetLabel(),\r
1458                                                p,\r
1459                                                kTRUE,\r
1460                                                pos,\r
1461                                                kFALSE,\r
1462                                                covTr, \r
1463                                                (Short_t)esdTrackD->GetSign(),\r
1464                                                esdTrackD->GetITSClusterMap(), \r
1465                                                pid,\r
1466                                                vkink,\r
1467                                                kTRUE, // check if this is right\r
1468                                                vtx->UsesTrack(esdTrack->GetID()),\r
1469                                                AliAODTrack::kSecondary,\r
1470                                                selectInfo);\r
1471             daughter->SetTPCClusterMap(esdTrackD->GetTPCClusterMap());\r
1472             daughter->SetTPCSharedMap (esdTrackD->GetTPCSharedMap());\r
1473             daughter->SetTPCPointsF(esdTrackD->GetTPCNclsF());\r
1474             fAODTrackRefs->AddAt(daughter, idaughter);\r
1475             \r
1476             if (esdTrackD->GetSign() > 0) ++fNumberOfPositiveTracks;\r
1477             daughter->SetFlags(esdTrackD->GetStatus());\r
1478             daughter->ConvertAliPIDtoAODPID();\r
1479             vkink->AddDaughter(daughter);\r
1480             daughter->ConvertAliPIDtoAODPID();\r
1481             SetAODPID(esdTrackD,daughter,detpid);\r
1482           }\r
1483           else {\r
1484             //                  cerr << "Error: event " << esd.GetEventNumberInFile() << " kink " << TMath::Abs(ikink)-1\r
1485             //                       << " track " << idaughter << " has already been used!" << endl;\r
1486           }\r
1487         }\r
1488             }\r
1489     }      \r
1490   }\r
1491 }\r
1492 \r
1493 //______________________________________________________________________________\r
1494 void AliAnalysisTaskESDfilter::ConvertPrimaryVertices(const AliESDEvent& esd)\r
1495 {\r
1496   AliCodeTimerAuto("",0);\r
1497   \r
1498   // Access to the AOD container of vertices\r
1499   fNumberOfVertices = 0;\r
1500   \r
1501   Double_t pos[3] = { 0. };\r
1502   Double_t covVtx[6] = { 0. };\r
1503 \r
1504   // Add primary vertex. The primary tracks will be defined\r
1505   // after the loops on the composite objects (V0, cascades, kinks)\r
1506   const AliESDVertex *vtx = esd.GetPrimaryVertex();\r
1507   \r
1508   vtx->GetXYZ(pos); // position\r
1509   vtx->GetCovMatrix(covVtx); //covariance matrix\r
1510   \r
1511   fPrimaryVertex = new(Vertices()[fNumberOfVertices++])\r
1512   AliAODVertex(pos, covVtx, vtx->GetChi2toNDF(), NULL, -1, AliAODVertex::kPrimary);\r
1513   fPrimaryVertex->SetName(vtx->GetName());\r
1514   fPrimaryVertex->SetTitle(vtx->GetTitle());\r
1515   \r
1516   TString vtitle = vtx->GetTitle();\r
1517   if (!vtitle.Contains("VertexerTracks")) \r
1518     fPrimaryVertex->SetNContributors(vtx->GetNContributors());\r
1519   \r
1520   if (fDebug > 0) fPrimaryVertex->Print();  \r
1521   \r
1522   // Add SPD "main" vertex \r
1523   const AliESDVertex *vtxS = esd.GetPrimaryVertexSPD();\r
1524   vtxS->GetXYZ(pos); // position\r
1525   vtxS->GetCovMatrix(covVtx); //covariance matrix\r
1526   AliAODVertex * mVSPD = new(Vertices()[fNumberOfVertices++])\r
1527   AliAODVertex(pos, covVtx, vtxS->GetChi2toNDF(), NULL, -1, AliAODVertex::kMainSPD);\r
1528   mVSPD->SetName(vtxS->GetName());\r
1529   mVSPD->SetTitle(vtxS->GetTitle());\r
1530   mVSPD->SetNContributors(vtxS->GetNContributors()); \r
1531   \r
1532   // Add SPD pileup vertices\r
1533   for(Int_t iV=0; iV<esd.GetNumberOfPileupVerticesSPD(); ++iV)\r
1534   {\r
1535     const AliESDVertex *vtxP = esd.GetPileupVertexSPD(iV);\r
1536     vtxP->GetXYZ(pos); // position\r
1537     vtxP->GetCovMatrix(covVtx); //covariance matrix\r
1538     AliAODVertex * pVSPD =  new(Vertices()[fNumberOfVertices++])\r
1539     AliAODVertex(pos, covVtx, vtxP->GetChi2toNDF(), NULL, -1, AliAODVertex::kPileupSPD);\r
1540     pVSPD->SetName(vtxP->GetName());\r
1541     pVSPD->SetTitle(vtxP->GetTitle());\r
1542     pVSPD->SetNContributors(vtxP->GetNContributors()); \r
1543   }\r
1544   \r
1545   // Add TRK pileup vertices\r
1546   for(Int_t iV=0; iV<esd.GetNumberOfPileupVerticesTracks(); ++iV)\r
1547   {\r
1548     const AliESDVertex *vtxP = esd.GetPileupVertexTracks(iV);\r
1549     vtxP->GetXYZ(pos); // position\r
1550     vtxP->GetCovMatrix(covVtx); //covariance matrix\r
1551     AliAODVertex * pVTRK = new(Vertices()[fNumberOfVertices++])\r
1552     AliAODVertex(pos, covVtx, vtxP->GetChi2toNDF(), NULL, -1, AliAODVertex::kPileupTracks);\r
1553     pVTRK->SetName(vtxP->GetName());\r
1554     pVTRK->SetTitle(vtxP->GetTitle());\r
1555     pVTRK->SetNContributors(vtxP->GetNContributors());\r
1556   }\r
1557 }\r
1558 \r
1559 //______________________________________________________________________________\r
1560 void AliAnalysisTaskESDfilter::ConvertVZERO(const AliESDEvent& esd)\r
1561 {\r
1562   // Convert VZERO data\r
1563   AliAODVZERO* vzeroData = AODEvent()->GetVZEROData();\r
1564   *vzeroData = *(esd.GetVZEROData());\r
1565 }\r
1566 \r
1567 //______________________________________________________________________________\r
1568 void AliAnalysisTaskESDfilter::ConvertZDC(const AliESDEvent& esd)\r
1569 {\r
1570   // Convert ZDC data\r
1571   AliESDZDC* esdZDC = esd.GetZDCData();\r
1572   \r
1573   const Double_t zem1Energy = esdZDC->GetZEM1Energy();\r
1574   const Double_t zem2Energy = esdZDC->GetZEM2Energy();\r
1575    \r
1576   const Double_t *towZNC = esdZDC->GetZNCTowerEnergy();\r
1577   const Double_t *towZPC = esdZDC->GetZPCTowerEnergy();\r
1578   const Double_t *towZNA = esdZDC->GetZNATowerEnergy();\r
1579   const Double_t *towZPA = esdZDC->GetZPATowerEnergy();\r
1580   const Double_t *towZNCLG = esdZDC->GetZNCTowerEnergyLR();\r
1581   const Double_t *towZNALG = esdZDC->GetZNATowerEnergyLR();\r
1582   \r
1583   AliAODZDC* zdcAOD = AODEvent()->GetZDCData();\r
1584 \r
1585   zdcAOD->SetZEM1Energy(zem1Energy);\r
1586   zdcAOD->SetZEM2Energy(zem2Energy);\r
1587   zdcAOD->SetZNCTowers(towZNC, towZNCLG);\r
1588   zdcAOD->SetZNATowers(towZNA, towZNALG);\r
1589   zdcAOD->SetZPCTowers(towZPC);\r
1590   zdcAOD->SetZPATowers(towZPA);\r
1591   \r
1592   zdcAOD->SetZDCParticipants(esdZDC->GetZDCParticipants(), esdZDC->GetZDCPartSideA(), esdZDC->GetZDCPartSideC());\r
1593   zdcAOD->SetZDCImpactParameter(esdZDC->GetImpactParameter(), esdZDC->GetImpactParamSideA(), \r
1594         esdZDC->GetImpactParamSideC());\r
1595   zdcAOD->SetZDCTDCSum(esdZDC->GetZNTDCSum(0)); \r
1596   zdcAOD->SetZDCTDCDiff(esdZDC->GetZNTDCDiff(0));       \r
1597 \r
1598 }\r
1599 \r
1600 //______________________________________________________________________________\r
1601 void AliAnalysisTaskESDfilter::ConvertESDtoAOD() \r
1602 {\r
1603   // ESD Filter analysis task executed for each event\r
1604   \r
1605   AliESDEvent* esd = dynamic_cast<AliESDEvent*>(InputEvent());\r
1606   \r
1607   if(!esd)return;\r
1608 \r
1609   AliCodeTimerAuto("",0);\r
1610   \r
1611   fOldESDformat = ( esd->GetAliESDOld() != 0x0 );\r
1612   \r
1613   fNumberOfTracks = 0;\r
1614   fNumberOfPositiveTracks = 0;\r
1615   fNumberOfV0s = 0;\r
1616   fNumberOfVertices = 0;\r
1617   fNumberOfCascades = 0;\r
1618   fNumberOfKinks = 0;\r
1619     \r
1620   AliAODHeader* header = ConvertHeader(*esd);\r
1621 \r
1622   if ( fIsVZEROEnabled ) ConvertVZERO(*esd);\r
1623   \r
1624   // Fetch Stack for debuggging if available \r
1625   fMChandler=0x0;\r
1626   if(MCEvent())\r
1627   {\r
1628     fMChandler = (AliMCEventHandler*) ((AliAnalysisManager::GetAnalysisManager())->GetMCtruthEventHandler()); \r
1629   }\r
1630   \r
1631   // loop over events and fill them\r
1632   // Multiplicity information needed by the header (to be revised!)\r
1633   Int_t nTracks    = esd->GetNumberOfTracks();\r
1634   for (Int_t iTrack=0; iTrack<nTracks; ++iTrack) esd->GetTrack(iTrack)->SetESDEvent(esd);\r
1635 \r
1636   // Update the header\r
1637 \r
1638   Int_t nV0s      = esd->GetNumberOfV0s();\r
1639   Int_t nCascades = esd->GetNumberOfCascades();\r
1640   Int_t nKinks    = esd->GetNumberOfKinks();\r
1641   Int_t nVertices = nV0s + nCascades /*V0 wihtin cascade already counted*/+ nKinks + 1 /* = prim. vtx*/;\r
1642   Int_t nPileSPDVertices=1+esd->GetNumberOfPileupVerticesSPD(); // also SPD main vertex\r
1643   Int_t nPileTrkVertices=esd->GetNumberOfPileupVerticesTracks();\r
1644   nVertices+=nPileSPDVertices;\r
1645   nVertices+=nPileTrkVertices;\r
1646   Int_t nJets     = 0;\r
1647   Int_t nCaloClus = esd->GetNumberOfCaloClusters();\r
1648   Int_t nFmdClus  = 0;\r
1649   Int_t nPmdClus  = esd->GetNumberOfPmdTracks();\r
1650     \r
1651   AliDebug(1,Form("   NV0=%d  NCASCADES=%d  NKINKS=%d", nV0s, nCascades, nKinks));\r
1652        \r
1653   AODEvent()->ResetStd(nTracks, nVertices, nV0s, nCascades, nJets, nCaloClus, nFmdClus, nPmdClus);\r
1654 \r
1655   if (nV0s > 0) \r
1656   {\r
1657     // RefArray to store a mapping between esd V0 number and newly created AOD-Vertex V0\r
1658     fAODV0VtxRefs = new TRefArray(nV0s);\r
1659     // RefArray to store the mapping between esd V0 number and newly created AOD-V0\r
1660     fAODV0Refs = new TRefArray(nV0s); \r
1661     // Array to take into account the V0s already added to the AOD (V0 within cascades)\r
1662     fUsedV0 = new Bool_t[nV0s];\r
1663     for (Int_t iV0=0; iV0<nV0s; ++iV0) fUsedV0[iV0]=kFALSE;\r
1664   }\r
1665   \r
1666   if (nTracks>0) \r
1667   {\r
1668     // RefArray to store the mapping between esd track number and newly created AOD-Track\r
1669     \r
1670     fAODTrackRefs = new TRefArray(nTracks);\r
1671 \r
1672     // Array to take into account the tracks already added to the AOD    \r
1673     fUsedTrack = new Bool_t[nTracks];\r
1674     for (Int_t iTrack=0; iTrack<nTracks; ++iTrack) fUsedTrack[iTrack]=kFALSE;\r
1675   }\r
1676   \r
1677   // Array to take into account the kinks already added to the AOD\r
1678   if (nKinks>0) \r
1679   {\r
1680     fUsedKink = new Bool_t[nKinks];\r
1681     for (Int_t iKink=0; iKink<nKinks; ++iKink) fUsedKink[iKink]=kFALSE;\r
1682   }\r
1683     \r
1684   ConvertPrimaryVertices(*esd);\r
1685 \r
1686   //setting best TOF PID\r
1687   AliESDInputHandler* esdH = dynamic_cast<AliESDInputHandler*>(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler());\r
1688   if (esdH)\r
1689       fESDpid = esdH->GetESDpid();\r
1690 \r
1691   if (fIsPidOwner && fESDpid){\r
1692     delete fESDpid;\r
1693     fESDpid = 0;\r
1694   }\r
1695   if(!fESDpid)\r
1696   { //in case of no Tender attached \r
1697     fESDpid = new AliESDpid;\r
1698     fIsPidOwner = kTRUE;\r
1699   }\r
1700   \r
1701   if(!esd->GetTOFHeader())\r
1702   { //protection in case the pass2 LHC10b,c,d have been processed without tender. \r
1703     Float_t t0spread[10];\r
1704     Float_t intrinsicTOFres=100; //ps ok for LHC10b,c,d pass2!! \r
1705     for (Int_t i=0; i<10; i++) t0spread[i] = (TMath::Sqrt(esd->GetSigma2DiamondZ()))/0.03; //0.03 to convert from cm to ps\r
1706     fESDpid->GetTOFResponse().SetT0resolution(t0spread);\r
1707     fESDpid->GetTOFResponse().SetTimeResolution(intrinsicTOFres);\r
1708     \r
1709     fESDpid->SetTOFResponse(esd, (AliESDpid::EStartTimeType_t)fTimeZeroType);    \r
1710   }\r
1711   \r
1712   if(esd->GetTOFHeader() && fIsPidOwner) fESDpid->SetTOFResponse(esd, (AliESDpid::EStartTimeType_t)fTimeZeroType); //in case of AOD production strating form LHC10e without Tender. \r
1713   \r
1714   if ( fAreCascadesEnabled ) ConvertCascades(*esd);\r
1715 \r
1716   if ( fAreV0sEnabled ) ConvertV0s(*esd);\r
1717   \r
1718   if ( fAreKinksEnabled ) ConvertKinks(*esd);\r
1719   \r
1720   if ( fAreTracksEnabled ) ConvertTracks(*esd);\r
1721   \r
1722   // Update number of AOD tracks in header at the end of track loop (M.G.)\r
1723   header->SetRefMultiplicity(fNumberOfTracks);\r
1724   header->SetRefMultiplicityPos(fNumberOfPositiveTracks);\r
1725   header->SetRefMultiplicityNeg(fNumberOfTracks - fNumberOfPositiveTracks);\r
1726 \r
1727   if ( fTPCOnlyFilterMask ) ConvertTPCOnlyTracks(*esd);\r
1728   \r
1729   if ( fArePmdClustersEnabled ) ConvertPmdClusters(*esd);\r
1730   \r
1731   if ( fAreCaloClustersEnabled ) ConvertCaloClusters(*esd);\r
1732   \r
1733   if ( fAreEMCALCellsEnabled )ConvertEMCALCells(*esd);\r
1734   \r
1735   if ( fArePHOSCellsEnabled )ConvertPHOSCells(*esd);\r
1736   \r
1737   if ( fAreTrackletsEnabled ) ConvertTracklets(*esd);\r
1738   \r
1739   delete fAODTrackRefs; fAODTrackRefs=0x0;\r
1740   delete fAODV0VtxRefs; fAODV0VtxRefs=0x0;\r
1741   delete fAODV0Refs; fAODV0Refs=0x0;\r
1742   \r
1743   delete[] fUsedTrack; fUsedTrack=0x0;\r
1744   delete[] fUsedV0; fUsedV0=0x0;\r
1745   delete[] fUsedKink; fUsedKink=0x0;\r
1746 \r
1747   if ( fIsPidOwner){\r
1748     delete fESDpid;\r
1749     fESDpid = 0x0;\r
1750   }\r
1751 \r
1752 \r
1753 }\r
1754 \r
1755 \r
1756 //______________________________________________________________________________\r
1757 void AliAnalysisTaskESDfilter::SetAODPID(AliESDtrack *esdtrack, AliAODTrack *aodtrack, AliAODPid *detpid)\r
1758 {\r
1759   //\r
1760   // Setter for the raw PID detector signals\r
1761   //\r
1762 \r
1763   // Save PID object for candidate electrons\r
1764     Bool_t pidSave = kFALSE;\r
1765     if (fTrackFilter) {\r
1766         Bool_t selectInfo = fTrackFilter->IsSelected((char*) "Electrons");\r
1767         if (selectInfo)  pidSave = kTRUE;\r
1768     }\r
1769 \r
1770 \r
1771     // Tracks passing pt cut \r
1772     if(esdtrack->Pt()>fHighPthreshold) {\r
1773         pidSave = kTRUE;\r
1774     } else {\r
1775         if(fPtshape){\r
1776             if(esdtrack->Pt()> fPtshape->GetXmin()){\r
1777                 Double_t y = fPtshape->Eval(esdtrack->Pt())/fPtshape->Eval(fHighPthreshold);\r
1778                 if(gRandom->Rndm(0)<1./y){\r
1779                     pidSave = kTRUE;\r
1780                 }//end rndm\r
1781             }//end if p < pmin\r
1782         }//end if p function\r
1783     }// end else\r
1784 \r
1785     if (pidSave) {\r
1786       if(!aodtrack->GetDetPid()){// prevent memory leak when calling SetAODPID twice for the same track\r
1787         detpid = new AliAODPid();\r
1788         SetDetectorRawSignals(detpid,esdtrack);\r
1789         aodtrack->SetDetPID(detpid);\r
1790       }\r
1791     }\r
1792 }\r
1793 \r
1794 //______________________________________________________________________________\r
1795 void AliAnalysisTaskESDfilter::SetDetectorRawSignals(AliAODPid *aodpid, AliESDtrack *track)\r
1796 {\r
1797 //\r
1798 //assignment of the detector signals (AliXXXesdPID inspired)\r
1799 //\r
1800  if(!track){\r
1801  AliInfo("no ESD track found. .....exiting");\r
1802  return;\r
1803  }\r
1804  // TPC momentum\r
1805  const AliExternalTrackParam *in=track->GetInnerParam();\r
1806  if (in) {\r
1807    aodpid->SetTPCmomentum(in->GetP());\r
1808  }else{\r
1809    aodpid->SetTPCmomentum(-1.);\r
1810  }\r
1811 \r
1812 \r
1813  aodpid->SetITSsignal(track->GetITSsignal());\r
1814  aodpid->SetTPCsignal(track->GetTPCsignal());\r
1815  aodpid->SetTPCsignalN(track->GetTPCsignalN());\r
1816 \r
1817  //n TRD planes = 6\r
1818  Int_t nslices = track->GetNumberOfTRDslices()*6;\r
1819  Double_t *trdslices = new Double_t[nslices];\r
1820  for(Int_t iSl =0; iSl < track->GetNumberOfTRDslices(); iSl++) {\r
1821    for(Int_t iPl =0; iPl<6; iPl++) trdslices[iPl*track->GetNumberOfTRDslices()+iSl] = track->GetTRDslice(iPl,iSl);\r
1822  }\r
1823  \r
1824 //TRD momentum\r
1825  for(Int_t iPl=0;iPl<6;iPl++){\r
1826    Double_t trdmom=track->GetTRDmomentum(iPl);\r
1827    aodpid->SetTRDmomentum(iPl,trdmom);\r
1828  }\r
1829 \r
1830  aodpid->SetTRDsignal(track->GetNumberOfTRDslices()*6,trdslices);\r
1831 \r
1832  //TOF PID  \r
1833  Double_t times[AliAODPid::kSPECIES]; track->GetIntegratedTimes(times);\r
1834  aodpid->SetIntegratedTimes(times);\r
1835 \r
1836   Float_t tzeroTrack = fESDpid->GetTOFResponse().GetStartTime(track->P());\r
1837   aodpid->SetTOFsignal(track->GetTOFsignal()-tzeroTrack);\r
1838   \r
1839   Double_t tofRes[5];\r
1840   for (Int_t iMass=0; iMass<5; iMass++){\r
1841     tofRes[iMass]=(Double_t)fESDpid->GetTOFResponse().GetExpectedSigma(track->P(), times[iMass], AliPID::ParticleMass(iMass));\r
1842   }\r
1843   aodpid->SetTOFpidResolution(tofRes);\r
1844 \r
1845   aodpid->SetHMPIDsignal(track->GetHMPIDsignal());\r
1846 \r
1847  //Extrapolate track to EMCAL surface for AOD-level track-cluster matching\r
1848  Double_t emcpos[3] = {0.,0.,0.};\r
1849  Double_t emcmom[3] = {0.,0.,0.};\r
1850  aodpid->SetEMCALPosition(emcpos);\r
1851  aodpid->SetEMCALMomentum(emcmom);\r
1852 \r
1853  Double_t hmpPid[5] = {0};\r
1854  track->GetHMPIDpid(hmpPid);\r
1855  aodpid->SetHMPIDprobs(hmpPid);\r
1856 \r
1857  AliExternalTrackParam *outerparam = (AliExternalTrackParam*)track->GetOuterParam();\r
1858  if(!outerparam) return;\r
1859 \r
1860  //To be replaced by call to AliEMCALGeoUtils when the class becomes available\r
1861  Bool_t okpos = outerparam->GetXYZ(emcpos);\r
1862  Bool_t okmom = outerparam->GetPxPyPz(emcmom);\r
1863  if(!(okpos && okmom)) return;\r
1864 \r
1865  aodpid->SetEMCALPosition(emcpos);\r
1866  aodpid->SetEMCALMomentum(emcmom);\r
1867 \r
1868 }\r
1869 \r
1870 Double_t  AliAnalysisTaskESDfilter::Chi2perNDF(AliESDtrack* track)\r
1871 {\r
1872     // Calculate chi2 per ndf for track\r
1873     Int_t  nClustersTPC = track->GetTPCNcls();\r
1874 \r
1875     if ( nClustersTPC > 5) {\r
1876        return (track->GetTPCchi2()/Float_t(nClustersTPC - 5));\r
1877     } else {\r
1878        return (-1.);\r
1879     }\r
1880  }\r
1881 \r
1882 \r
1883 //______________________________________________________________________________\r
1884 void AliAnalysisTaskESDfilter::Terminate(Option_t */*option*/)\r
1885 {\r
1886 // Terminate analysis\r
1887 //\r
1888     if (fDebug > 1) printf("AnalysisESDfilter: Terminate() \n");\r
1889 }\r
1890 \r
1891 //______________________________________________________________________________\r
1892 void  AliAnalysisTaskESDfilter::PrintMCInfo(AliStack *pStack,Int_t label){\r
1893 // Print MC info\r
1894   if(!pStack)return;\r
1895   label = TMath::Abs(label);\r
1896   TParticle *part = pStack->Particle(label);\r
1897   Printf("########################");\r
1898   Printf("%s:%d %d UniqueID %d PDG %d P %3.3f",(char*)__FILE__,__LINE__,label,part->GetUniqueID(),part->GetPdgCode(),part->P());\r
1899   part->Print();\r
1900   TParticle* mother = part;\r
1901   Int_t imo = part->GetFirstMother();\r
1902   Int_t nprim = pStack->GetNprimary();\r
1903   //  while((imo >= nprim) && (mother->GetUniqueID() == 4)) {\r
1904   while((imo >= nprim)) {\r
1905     mother =  pStack->Particle(imo);\r
1906     Printf("Mother %s:%d Label %d UniqueID %d PDG %d P %3.3f",(char*)__FILE__,__LINE__,imo,mother->GetUniqueID(),mother->GetPdgCode(),mother->P());\r
1907     mother->Print();\r
1908     imo =  mother->GetFirstMother();\r
1909   }\r
1910   Printf("########################");\r
1911 }\r