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