PWG3/hfe/AliAnalysisTaskCheckV0tenderII.cxx

   1 /**************************************************************************
   2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   3 *                                                                        *
   4 * Author: The ALICE Off-line Project.                                    *
   5 * Contributors are mentioned in the code where appropriate.              *
   6 *                                                                        *
   7 * Permission to use, copy, modify and distribute this software and its   *
   8 * documentation strictly for non-commercial purposes is hereby granted   *
   9 * without fee, provided that the above copyright notice appears in all   *
  10 * copies and that both the copyright notice and this permission notice   *
  11 * appear in the supporting documentation. The authors make no claims     *
  12 * about the suitability of this software for any purpose. It is          *
  13 * provided "as is" without express or implied warranty.                  *
  14 **************************************************************************/
  15
  16 /* $Id$ */
  17
  18 //
  19 // Task for checking the performance of the V0 tender
  20 //
  21 //
  22 // Authors:
  23 //   Matus Kalisky <matus.kalisky@cern.ch>
  24 //
  25
  26 #include <TH1F.h>
  27 #include <TList.h>
  28
  29 #include "AliAnalysisManager.h"
  30 #include "AliMCEventHandler.h"
  31 #include "AliESDInputHandler.h"
  32 #include "AliESDv0.h"
  33 #include "AliESDtrack.h"
  34 #include "AliMCParticle.h"
  35 #include "AliMCEvent.h"
  36 #include "AliESDv0KineCuts.h"
  37 #include "AliKFVertex.h"
  38
  39 #include "AliHFEtools.h"
  40 #include "AliHFEcollection.h"
  41
  42 #include "AliAnalysisTaskCheckV0tenderII.h"
  43
  44 ClassImp(AliAnalysisTaskCheckV0tenderII)
  45
  46 //__________________________________________________________
  47 AliAnalysisTaskCheckV0tenderII::AliAnalysisTaskCheckV0tenderII():
  48   AliAnalysisTaskSE("CheckV0tenderTask")
  49   , fOutput(0x0)
  50   , fColl(0x0)
  51   , fCollMC(0x0)
  52   , fV0cuts(0x0)
  53   , fPrimaryVertex(0x0)
  54   , fpdgV0(-1)
  55   , fpdgP(-1)
  56   , fpdgN(-1)
  57   , fEvents(0x0)
  58 {
  59   //
  60   // Default Constructor
  61   //
  62
  63
  64   DefineOutput(1, TH1F::Class());
  65   DefineOutput(2, TList::Class());
  66
  67
  68 }
  69 //__________________________________________________________
  70 AliAnalysisTaskCheckV0tenderII::AliAnalysisTaskCheckV0tenderII(const Char_t *name):
  71   AliAnalysisTaskSE(name)
  72   , fOutput(0x0)
  73   , fColl(0x0)
  74   , fCollMC(0x0)
  75   , fV0cuts(0x0)
  76   , fPrimaryVertex(0x0)
  77   , fpdgV0(0)
  78   , fpdgP(0)
  79   , fpdgN(0)
  80   , fEvents(0x0)
  81 {
  82   //
  83   // Constructor
  84   //
  85
  86   DefineOutput(1, TH1F::Class());
  87   DefineOutput(2, TList::Class());
  88
  89 }
  90 //__________________________________________________________
  91 AliAnalysisTaskCheckV0tenderII::~AliAnalysisTaskCheckV0tenderII(){
  92   //
  93   // Destructor
  94   //
  95
  96   if (fOutput) delete fOutput;
  97   //if (fColl) delete fColl;
  98   //if (fCollMC) delete fCollMC;
  99   if (fV0cuts) delete fV0cuts;
 100   if (fPrimaryVertex) delete fPrimaryVertex;
 101   if (fEvents) delete fEvents;
 102 }
 103 //__________________________________________________________
 104 void AliAnalysisTaskCheckV0tenderII::UserCreateOutputObjects(){
 105   //
 106   // prepare output objects
 107   //
 108
 109   fOutput = new TList();
 110   //fOutput->SetOwner();
 111   // Counter for number of events
 112   fEvents = new TH1I("nEvents", "NumberOfEvents", 1, 1, 2);
 113
 114   fColl = new AliHFEcollection("V0_QA", "tender V0s for data");
 115   fCollMC = new AliHFEcollection("V0_MC_QA", "tender V0s for MC");
 116
 117   fV0cuts = new AliESDv0KineCuts();
 118   if(!fV0cuts){
 119     AliError("Failed to initialize AliESDv0KineCuts instance");
 120     return;
 121   }
 122
 123   //
 124   // Data histos
 125   //
 126
 127   // total number of tagged V0s
 128   fColl->CreateTH1F("h_NumberOf_V0s", "Number of tagged V0s; type; counts", 4, -0.5, 3.5);
 129   // pT spectra of the tagged V0s
 130   fColl->CreateTH1F("h_Gamma_pt", "p_{T} spectrum of tagged gammas; p_{T} (GeV/c); counts", 20, 0.1, 20, 0);
 131   fColl->CreateTH1F("h_K0_pt", "p_{T} spectrum of tagged K0s; p_{T} (GeV/c); counts", 20, 0.1, 20, 0);
 132   fColl->CreateTH1F("h_Lambda_pt", "p_{T} spectrum of tagged Lambdas; p_{T} (GeV/c); counts", 20, 0.1, 20, 0);
 133   fColl->CreateTH1F("h_ALambda_pt", "p_{T} spectrum of tagged A-Lambdas; p_{T} (GeV/c); counts", 20, 0.1, 20, 0);
 134   // invariant mass of the V0s
 135   fColl->CreateTH1F("h_Gamma_mass", "Inv. Mass of the ", 100, 0., 0.1);
 136   fColl->CreateTH1F("h_K0_mass", "Inv. Mass of the ", 100, 0.45, 0.55);
 137   fColl->CreateTH1F("h_Lambda_mass", "Inv. Mass of the ", 100, 1.08, 1.14);
 138   fColl->CreateTH1F("h_ALambda_mass", "Inv. Mass of the ", 100, 1.08, 1.14);
 139
 140   // total number of tagged daughter particles (should correlate with number of V0s !
 141   fColl->CreateTH1F("h_NumberOfDaughters", "Number of tagged daughters; type; counts", 3, -0.5, 2.5);
 142   // pT spectra of tagged daughter particles
 143   fColl->CreateTH1F("h_Electron_pt", "p_{T} spectrum of tagged; p_{T} (GeV/c); counts", 20, 0.1, 20, 0);
 144   fColl->CreateTH1F("h_Pion_pt", "p_{T} spectrum of tagged; p_{T} (GeV/c); counts", 20, 0.1, 20, 0);
 145   fColl->CreateTH1F("h_Proton_pt", "p_{T} spectrum of tagged; p_{T} (GeV/c); counts", 20, 0.1, 20, 0);
 146
 147   //
 148   // MC histos
 149   //
 150
 151   // pT spectra of the tagged V0s
 152   fCollMC->CreateTH1F("h_Gamma_pt_S", "MC-S: p_{T} spectrum of tagged gammas; p_{T} (GeV/c); counts", 20, 0.1, 20, 0);
 153   fCollMC->CreateTH1F("h_K0_pt_S", "MC-S: p_{T} spectrum of tagged K0s; p_{T} (GeV/c); counts", 20, 0.1, 20, 0);
 154   fCollMC->CreateTH1F("h_Lambda_pt_S", "MC-S: p_{T} spectrum of tagged Lambdas; p_{T} (GeV/c); counts", 20, 0.1, 20, 0);
 155   fCollMC->CreateTH1F("h_ALambda_pt_S", "MC-S: p_{T} spectrum of tagged A-Lambdas; p_{T} (GeV/c); counts", 20, 0.1, 20, 0);
 156   fCollMC->CreateTH1F("h_Gamma_pt_B", "MC-B: p_{T} spectrum of tagged gammas; p_{T} (GeV/c); counts", 20, 0.1, 20, 0);
 157   fCollMC->CreateTH1F("h_K0_pt_B", "MC-B: p_{T} spectrum of tagged K0s; p_{T} (GeV/c); counts", 20, 0.1, 20, 0);
 158   fCollMC->CreateTH1F("h_Lambda_pt_B", "MC-B: p_{T} spectrum of tagged Lambdas; p_{T} (GeV/c); counts", 20, 0.1, 20, 0);
 159   fCollMC->CreateTH1F("h_ALambda_pt_B", "MC-B: p_{T} spectrum of tagged A-Lambdas; p_{T} (GeV/c); counts", 20, 0.1, 20, 0);
 160   // invariant mass of the V0s
 161   fCollMC->CreateTH1F("h_Gamma_mass_S", "MC-S: Inv. Mass of the gamma; m (GeV/c^{2}); counts", 100, 0., 0.1);
 162   fCollMC->CreateTH1F("h_K0_mass_S", "MC-S: Inv. Mass of the K0; m (GeV/c^{2}); counts", 100, 0.45, 0.55);
 163   fCollMC->CreateTH1F("h_Lambda_mass_S", "MC-S: Inv. Mass of the Lambda; m (GeV/c^{2}); counts", 100, 1.08, 1.14);
 164   fCollMC->CreateTH1F("h_ALambda_mass_S", "MC-S: Inv. Mass of the A-Lambda; m (GeV/c^{2}); counts", 100, 1.08, 1.14);
 165   fCollMC->CreateTH1F("h_Gamma_mass_B", "MC-B: Inv. Mass of the gamma; m (GeV/c^{2}); counts", 100, 0., 0.1);
 166   fCollMC->CreateTH1F("h_K0_mass_B", "MC-B: Inv. Mass of the K0; m (GeV/c^{2}); counts", 100, 0.45, 0.55);
 167   fCollMC->CreateTH1F("h_Lambda_mass_B", "MC-B: Inv. Mass of the Lambda; m (GeV/c^{2}); counts", 100, 1.08, 1.14);
 168   fCollMC->CreateTH1F("h_ALambda_mass_B", "MC-B: Inv. Mass of the A-Lambda; m (GeV/c^{2}); counts", 100, 1.08, 1.14);
 169   // pT spectra of tagged daughter particles
 170   fCollMC->CreateTH1F("h_Electron_pt_S", "MC-S: p_{T} spectrum of tagged electrons; p_{T} (GeV/c); counts", 20, 0.1, 20, 0);
 171   fCollMC->CreateTH1F("h_Pion_pt_S", "MC-S: p_{T} spectrum of tagged pions; p_{T} (GeV/c); counts", 20, 0.1, 20, 0);
 172   fCollMC->CreateTH1F("h_Proton_pt_S", "MC-S: p_{T} spectrum of tagged protons; p_{T} (GeV/c); counts", 20, 0.1, 20, 0);
 173   fCollMC->CreateTH1F("h_Electron_pt_B", "MC-B: p_{T} spectrum of tagged electrons; p_{T} (GeV/c); counts", 20, 0.1, 20, 0);
 174   fCollMC->CreateTH1F("h_Pion_pt_B", "MC-B: p_{T} spectrum of tagged pions; p_{T} (GeV/c); counts", 20, 0.1, 20, 0);
 175   fCollMC->CreateTH1F("h_Proton_pt_B", "MC-B: p_{T} spectrum of tagged protons; p_{T} (GeV/c); counts", 20, 0.1, 20, 0);
 176   // background study - MC only
 177   fCollMC->CreateTH1Fvector1(6, "h_Gamma_Bg", "MC gamma bg. - different sources; p_{T} (GeV/c), counts", 20, 0.1, 20, 0);
 178   fCollMC->CreateTH1Fvector1(6, "h_K0_Bg", "MC K0 bg. - different sources; p_{T} (GeV/c), counts", 20, 0.1, 20, 0);
 179   fCollMC->CreateTH1Fvector1(6, "h_Lambda_Bg", "MC gamma bg. - different sources; p_{T} (GeV/c), counts", 20, 0.1, 20, 0);
 180   fCollMC->CreateTH1Fvector1(6, "h_ALambda_Bg", "MC gamma bg. - different sources; p_{T} (GeV/c), counts", 20, 0.1, 20, 0);
 181
 182
 183   TList *tmp = fColl->GetList();
 184   tmp->SetName(fColl->GetName());
 185   fOutput->Add(tmp);
 186   tmp = 0x0;
 187   tmp = fCollMC->GetList();
 188   tmp->SetName(fCollMC->GetName());
 189   fOutput->Add(tmp);
 190
 191
 192 }
 193 //__________________________________________________________
 194 void AliAnalysisTaskCheckV0tenderII::UserExec(Option_t *){
 195   //
 196   // Event Loop
 197   //
 198   AliMCEventHandler* mcHandler = (dynamic_cast<AliMCEventHandler*>(AliAnalysisManager::GetAnalysisManager()->GetMCtruthEventHandler()));
 199
 200   //AliESDInputHandler *inh = dynamic_cast<AliESDInputHandler *>(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler());
 201   //AliESDpid *workingPID = NULL;
 202   //if(inh && (workingPID = inh->GetESDpid())) workingPID = inh->GetESDpid();
 203   //else workingPID = AliHFEtools::GetDefaultPID(mcHandler ? kTRUE : kFALSE);
 204
 205   // check the MC data
 206   if(fMCEvent && !mcHandler ) return;
 207   if(fMCEvent &&  !mcHandler->InitOk() ) return;
 208   if(fMCEvent &&  !mcHandler->TreeK() ) return;
 209   if(fMCEvent &&  !mcHandler->TreeTR() ) return;
 210
 211   AliKFVertex *primaryVertex = new AliKFVertex(*(fInputEvent->GetPrimaryVertex()));
 212   if(!primaryVertex) return;
 213
 214   fV0cuts->SetPrimaryVertex(primaryVertex);
 215   fV0cuts->SetEvent(fInputEvent);
 216
 217   ProcessV0s();
 218
 219
 220   if (primaryVertex) delete primaryVertex;
 221   fEvents->Fill(1.1);
 222   PostData(1, fEvents);
 223   PostData(2, fOutput);
 224 }
 225 //__________________________________________________________
 226 void AliAnalysisTaskCheckV0tenderII::Terminate(Option_t *){
 227   //
 228   // Do Post Processing
 229   //
 230 }
 231 //__________________________________________________________
 232 void AliAnalysisTaskCheckV0tenderII::ProcessV0s(){
 233   //
 234   // loop over the V0s and extract the information about
 235   // the V0s tagged by the V0 tender
 236   //
 237
 238   const TString type[4] = {"Gamma", "K0", "Lambda", "ALambda"};
 239   TString name;
 240
 241   Int_t nV0s = fInputEvent->GetNumberOfV0s();
 242   for(Int_t i=0; i<nV0s; ++i){
 243     AliESDv0 *esdV0 = (static_cast<AliESDEvent *>(fInputEvent))->GetV0(i);
 244     if(!esdV0) continue;
 245     if(!esdV0->GetOnFlyStatus()) continue; // Take only V0s from the On-the-fly v0 finder
 246
 247     ResetPDGcodes();
 248
 249     // New standalone V0 selection software
 250     if( ! (fV0cuts->ProcessV0(esdV0, fpdgV0, fpdgP, fpdgN)) ) continue;
 251
 252     Int_t pid = PDGtoPIDv0(fpdgV0);
 253     //printf(" -D: pdg: %i, pid: %i\n", fpdgV0, pid);
 254     if(pid <= -1) continue;
 255
 256     fColl->Fill("h_NumberOf_V0s", pid);
 257     name = "h_" + type[pid] + "_pt";
 258     Float_t pT = esdV0->Pt();
 259     fColl->Fill(name, pT);
 260     Float_t mass = MassV0(esdV0, pid);
 261     name = "h_" + type[pid] + "_mass";
 262     fColl->Fill(name, mass);
 263
 264     ProcessDaughters(esdV0);
 265     if(fMCEvent){
 266       ProcessV0sMC(esdV0);
 267       ProcessDaughtersMC(esdV0);
 268       ProcessBackground(esdV0);
 269     }
 270
 271   }
 272
 273 }
 274 //__________________________________________________________
 275 void AliAnalysisTaskCheckV0tenderII::ProcessDaughters(AliESDv0 * const v0){
 276   //
 277   // produce some check plots for V0 tender tagged single tracks
 278   //
 279
 280   const TString type[3] = {"Electron", "Pion", "Proton"};
 281   TString name;
 282
 283   if(!v0) return;
 284
 285   // daughter tracks
 286   const Int_t nTracks = fInputEvent->GetNumberOfTracks();
 287   AliESDtrack *d[2];
 288   Int_t iN, iP;
 289   iN = iP = -1;
 290   iP = v0->GetPindex();
 291   iN = v0->GetNindex();
 292   if(iN < 0 || iP < 0) return;
 293   if(iN >= nTracks || iP >= nTracks) return;
 294   d[0] = dynamic_cast<AliESDtrack *>(fInputEvent->GetTrack(iP));
 295   d[1] = dynamic_cast<AliESDtrack *>(fInputEvent->GetTrack(iN));
 296   if(!d[0] || !d[1]) return;
 297
 298   for(Int_t i=0; i<2; ++i){
 299     Int_t  pid = (i == 0) ? PDGtoPID(fpdgP) : PDGtoPID(fpdgN);
 300     if(pid < 0) continue;
 301     fColl->Fill("h_NumberOfDaughters", pid*1.0);
 302     Float_t pT = d[i]->Pt();
 303     name = "h_" + type[pid] + "_pt";
 304     fColl->Fill(name, pT);
 305   }
 306 }
 307 //__________________________________________________________
 308 void AliAnalysisTaskCheckV0tenderII::ProcessV0sMC(AliESDv0 * const v0){
 309   //
 310   // check all V0tender selected V0 on their true identity
 311   //
 312
 313   const TString type[4] = {"Gamma", "K0", "Lambda", "ALambda"};
 314   TString name;
 315
 316   Int_t pid = PDGtoPIDv0(fpdgV0);
 317   if(pid < 0) return;
 318
 319   // true if fpdgV0 agrees with MC pdg of the mother
 320   Bool_t id = kFALSE;
 321   const Int_t nTracks = fInputEvent->GetNumberOfTracks();
 322   // both ESD daughtr tracks
 323   Int_t iN, iP;
 324   iN = iP = -1;
 325   iP = v0->GetPindex();
 326   iN = v0->GetNindex();
 327   if(iN < 0 || iP < 0) return;
 328   if(iN >= nTracks || iP >= nTracks) return;
 329   AliESDtrack *dP, *dN;
 330   dP = dynamic_cast<AliESDtrack *>(fInputEvent->GetTrack(iP));
 331   dN = dynamic_cast<AliESDtrack *>(fInputEvent->GetTrack(iN));
 332   if(!dN || !dP) return;
 333
 334   // MC labels of the daughter tracks
 335   Int_t lN, lP;
 336   lN = dN->GetLabel();
 337   lP = dP->GetLabel();
 338   if(lN < 0 || lP < 0) return;
 339
 340   // MC daughter particles
 341   AliMCParticle *mcP, *mcN;
 342   mcP = dynamic_cast<AliMCParticle*>(fMCEvent->GetTrack(lP));
 343   mcN = dynamic_cast<AliMCParticle*>(fMCEvent->GetTrack(lN));
 344   if(!mcP || !mcN) return;
 345
 346   // labels of the mother particles
 347   Int_t lPm, lNm;
 348   lPm = mcP->GetMother();
 349   lNm = mcN->GetMother();
 350   AliMCParticle *m = 0x0;
 351   // particles without mother particle are most probably
 352   // primary particles
 353   if(lPm >= 0){
 354     m = dynamic_cast<AliMCParticle*>(fMCEvent->GetTrack(lPm));
 355     if(!m) return;
 356   }
 357   if(m){
 358     Int_t pdg = m->PdgCode();
 359     //if(lPm == lNm) printf(" -D: pdg: %i, fpdgV0: %i \n", pdg, fpdgV0);
 360     if((lPm == lNm) && (pdg == fpdgV0)) id = kTRUE;
 361   }
 362
 363   if(id) name = "h_" + type[pid] + "_pt_S";
 364   else  name = "h_" + type[pid] + "_pt_B";
 365   Float_t pT = v0->Pt();
 366   fCollMC->Fill(name, pT);
 367
 368   if(id) name = "h_" + type[pid] + "_mass_S";
 369   else name = "h_" + type[pid] + "_mass_B";
 370   Float_t mass = MassV0(v0, pid);
 371   fCollMC->Fill(name, mass);
 372
 373
 374 }
 375 //__________________________________________________________
 376 void AliAnalysisTaskCheckV0tenderII::ProcessDaughtersMC(AliESDv0 * const v0){
 377   //
 378   // check the identity of the V0tender selected V0 daughters
 379   // !!! for positive check only the true identity plays a role here,
 380   // not the true V0 mother identity (e.g. selected electron could come
 381   // from primary vertex or pion dalitz deca or true gamma conversion) !!!!
 382   //
 383
 384   const TString type[3] = {"Electron", "Pion", "Proton"};
 385   TString name;
 386
 387   if(!v0) return;
 388
 389   // daughter tracks
 390   const Int_t nTracks = fInputEvent->GetNumberOfTracks();
 391   AliESDtrack *d[2];
 392   Int_t iN, iP;
 393   iN = iP = -1;
 394   iP = v0->GetPindex();
 395   iN = v0->GetNindex();
 396   if(iN < 0 || iP < 0) return;
 397   if(iN >= nTracks || iP >= nTracks) return;
 398   d[0] = dynamic_cast<AliESDtrack *>(fInputEvent->GetTrack(iP));
 399   d[1] = dynamic_cast<AliESDtrack *>(fInputEvent->GetTrack(iN));
 400   if(!d[0] || !d[1]) return;
 401
 402   //printf(" *** fpdgV0: %i, fpdgP: %i, fpdgN: %i \n", fpdgV0, fpdgP, fpdgN);
 403
 404   for(Int_t i=0; i<2; ++i){
 405     Bool_t id = kFALSE;
 406     Int_t  pid = (i == 0) ? PDGtoPID(fpdgP) : PDGtoPID(fpdgN);
 407     Int_t  pdg  = (i == 0) ? fpdgP : fpdgN;
 408     if(pid < 0) continue;
 409     Float_t pT = d[i]->Pt();
 410     Int_t label = d[i]->GetLabel();
 411     if(label < 0) continue;
 412     AliMCParticle *mcp = 0x0;
 413     mcp = dynamic_cast<AliMCParticle*>(fMCEvent->GetTrack(label));
 414     if(!mcp) continue;
 415     Int_t pdgMC = mcp->PdgCode();
 416     //printf("   * pid: %i, pdg: %i, pdgMC: %i \n", pid, pdg, pdgMC);
 417     if(pdgMC == pdg) id = kTRUE;
 418     if(id) name =  "h_" + type[pid] + "_pt_S";
 419     else name =  "h_" + type[pid] + "_pt_B";
 420     fCollMC->Fill(name, pT);
 421   }
 422 }
 423 //__________________________________________________________
 424 void  AliAnalysisTaskCheckV0tenderII::ProcessBackground(AliESDv0 * const v0){
 425   //
 426   // look at the compostition and the properties of the
 427   // miss-identified V0
 428   //
 429
 430   if(!v0) return;
 431   Float_t pt = v0->Pt();
 432   const TString type[4] = {"Gamma", "K0", "Lambda", "ALambda"};
 433   TString name;
 434   // daughter tracks
 435   const Int_t nTracks = fInputEvent->GetNumberOfTracks();
 436   AliESDtrack *d[2];
 437   Int_t index[2] = {-1, -1};
 438   index[0] = v0->GetPindex();
 439   index[1] = v0->GetNindex();
 440   if(index[0] < 0 || index[1] < 0) return;
 441   if(index[0] >= nTracks || index[1] >= nTracks) return;
 442   d[0] = dynamic_cast<AliESDtrack *>(fInputEvent->GetTrack(index[0]));
 443   d[1] = dynamic_cast<AliESDtrack *>(fInputEvent->GetTrack(index[1]));
 444   if(!d[0] || !d[1]) return;
 445
 446   // daughter MC particles
 447   Int_t label[2] = {d[0]->GetLabel(), d[1]->GetLabel()};
 448   if(label[0] < 0 || label[1] < 0) return;
 449   AliMCParticle *dmc[2] = {0x0, 0x0};
 450   dmc[0] = dynamic_cast<AliMCParticle*>(fMCEvent->GetTrack(label[0]));
 451   dmc[1] = dynamic_cast<AliMCParticle*>(fMCEvent->GetTrack(label[1]));
 452   if(!dmc[0]  || !dmc[1]) return;
 453
 454   Bool_t primary[2] = {dmc[0]->Particle()->IsPrimary(), dmc[1]->Particle()->IsPrimary()};
 455
 456   // mother MC particles
 457   Int_t labelM[2] = {dmc[0]->GetMother(), dmc[1]->GetMother()};
 458   AliMCParticle *mmc[2] = {0x0, 0x0};
 459   if(!primary[0])  mmc[0] = dynamic_cast<AliMCParticle*>(fMCEvent->GetTrack(labelM[0]));
 460   if(!primary[1])  mmc[1] = dynamic_cast<AliMCParticle*>(fMCEvent->GetTrack(labelM[1]));
 461
 462   // if particle is not primary it MUST have a mother particle
 463   if(!primary[0] && !mmc[0]) return;
 464   if(!primary[1] && !mmc[1]) return;
 465
 466   Int_t pdgM[2] = {0, 0};
 467   if(mmc[0]) pdgM[0] = mmc[0]->PdgCode();
 468   if(mmc[1]) pdgM[1] = mmc[1]->PdgCode();
 469
 470   // select only miss-identified V0s
 471   if(labelM[0] == labelM[1] && pdgM[0] == fpdgV0) return;
 472
 473   // indices for V0 background histograms
 474   // 0 - random match
 475   // 1 - gamma
 476   // 2 - K0
 477   // 3 - lambda
 478   // 4 - a-lambda
 479   // 5 - other dacay or interaction
 480
 481   Int_t ixM = -1;
 482
 483   Int_t typeV0  = (labelM[0] != labelM[1]) ? 0 : 1;
 484   if(0 == typeV0) ixM = 0;
 485   else{
 486     ixM = PDGtoPIDv0(pdgM[0]) + 1;
 487     if(ixM < 0) ixM = 5;
 488   }
 489   Int_t ix = PDGtoPIDv0(fpdgV0);
 490   if(0 <= ix ){
 491     name = "h_" + type[PDGtoPIDv0(fpdgV0)] + "_Bg";
 492     fCollMC->Fill(name, ixM, pt);
 493   }
 494
 495   // now look at the daughter tracks
 496
 497
 498 }
 499 //__________________________________________________________
 500 Float_t AliAnalysisTaskCheckV0tenderII::MassV0(AliESDv0 * const v0, Int_t id){
 501   //
 502   // Get the V0 effective mass
 503   //
 504
 505   Float_t mass = -0.1;
 506   Bool_t sign = CheckSigns(v0);
 507   if(0 == id){
 508     mass = v0->GetEffMass(0, 0);
 509   }
 510   else if(1 == id){
 511     mass = v0->GetEffMass(2, 2);
 512   }
 513   else if(2 == id){
 514     mass = (sign) ? v0->GetEffMass(4, 2) : v0->GetEffMass(2, 4);
 515   }
 516   else if(3 == id){
 517     mass = (sign) ? v0->GetEffMass(2, 4) : v0->GetEffMass(4, 2);
 518   }
 519   else{
 520     AliWarning(Form("Unrecognized V0 id: %i", id));
 521   }
 522
 523   return mass;
 524
 525 }
 526 //__________________________________________________________
 527 Bool_t AliAnalysisTaskCheckV0tenderII::CheckSigns(AliESDv0 * const v0){
 528   //
 529   // check wheter the sign was correctly applied to
 530   // V0 daughter tracks
 531   // This function should become obsolete once the V0 finder will be updated (fixed)
 532   //
 533
 534   Bool_t correct = kFALSE;
 535
 536   Int_t pIndex = 0, nIndex = 0;
 537   pIndex = v0->GetPindex();
 538   nIndex = v0->GetNindex();
 539
 540   AliESDtrack* d[2];
 541   d[0] = dynamic_cast<AliESDtrack*>(fInputEvent->GetTrack(pIndex));
 542   d[1] = dynamic_cast<AliESDtrack*>(fInputEvent->GetTrack(nIndex));
 543
 544   Int_t sign[2];
 545   sign[0] = (int)d[0]->GetSign();
 546   sign[1] = (int)d[1]->GetSign();
 547
 548   if(-1 == sign[0] && 1 == sign[1]){
 549     correct = kFALSE;
 550     //v0->SetIndex(0, pIndex);  // set the index of the negative v0 track
 551     //v0->SetIndex(1, nIndex);  // set the index of the positive v0 track
 552   }
 553   else{
 554     correct = kTRUE;
 555   }
 556
 557   //pIndex = v0->GetPindex();
 558   //nIndex = v0->GetNindex();
 559   //printf("-D2: P: %i, N: %i\n", pIndex, nIndex);
 560
 561   return correct;
 562 }
 563 //__________________________________________________________
 564 Int_t  AliAnalysisTaskCheckV0tenderII::PDGtoPIDv0(Int_t pdgV0) const {
 565   //
 566   // convert thereconstructed V0 pdg to local pid
 567   //
 568
 569   switch(pdgV0){
 570   case 22: return 0; break;
 571   case 310: return 1; break;
 572   case 3122: return 2; break;
 573   case -3122: return 3; break;
 574   }
 575
 576   return -1;
 577
 578 }
 579 //__________________________________________________________
 580 Int_t  AliAnalysisTaskCheckV0tenderII::PDGtoPID(Int_t pdg) const {
 581   //
 582   // convert daughter pdg code to local pid
 583   //
 584   switch(TMath::Abs(pdg)){
 585   case 11: return 0; break;
 586   case 211: return 1; break;
 587   case 2212: return 2; break;
 588   }
 589   return -1;
 590
 591 }
 592 //__________________________________________________________
 593 void  AliAnalysisTaskCheckV0tenderII::ResetPDGcodes(){
 594   //
 595   // reset the PDG codes of the V0 and daughter
 596   // particles to default values
 597   //
 598
 599   fpdgV0 = -1;
 600   fpdgP = -1;
 601   fpdgN = -1;
 602
 603 }