PWG3/hfe/AliHFEV0pidMC.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 // class to benchmark the V0 pid capabilties
  17 // runs over reconstructed V0 candidates and uses MC information for
  18 // further analysis [purity, PID perfortmance]
  19 //
  20 // authors:
  21 //    Matus Kalisky <matus.kalisky@cern.ch>
  22 //
  23
  24 #include "TIterator.h"
  25
  26 #include "AliVParticle.h"
  27 #include "AliESDtrack.h"
  28 #include "AliMCParticle.h"
  29 #include "AliMCEvent.h"
  30
  31 #include "AliHFEcollection.h"
  32
  33 #include "AliHFEV0pidMC.h"
  34 ClassImp(AliHFEV0pidMC)
  35
  36 //____________________________________________________________
  37   AliHFEV0pidMC::AliHFEV0pidMC():
  38     fMC(0x0)
  39     , fColl(NULL)
  40     , fV0cuts(NULL)
  41 {
  42   //
  43   // default constructor
  44   //
  45
  46 }
  47 //____________________________________________________________
  48 AliHFEV0pidMC::~AliHFEV0pidMC(){
  49   //
  50   // destructor
  51   //
  52   if (fColl) delete fColl;
  53   //if (fV0cuts) delete fV0cuts;
  54 }
  55 //____________________________________________________________
  56 void AliHFEV0pidMC::Init(){
  57   //
  58   // initialize objects
  59   //
  60
  61   fColl = new AliHFEcollection("V0pidMC", "MC based V0 benchmarking");
  62   // QA
  63   fColl->CreateTH1F("h_QA_nParticles", "QA on track processing", 10, -0.5, 9.5);
  64
  65   const Int_t nBins = 20;
  66   const Float_t pMin = 0.1;
  67   const Float_t pMax = 10.;
  68
  69   // before PID
  70   fColl->CreateTH1F("h_Electron", "all electron candidates (no MC); p (GeV/c); counts", nBins, pMin, pMax, 0);
  71   fColl->CreateTH1F("h_PionK0", "all K0 pion candidates (no MC); p (GeV/c); counts",  nBins, pMin, pMax, 0);
  72   fColl->CreateTH1F("h_PionL", "all Lambda pion candidates (no MC); p (GeV/c); counts", nBins, pMin, pMax, 0);
  73   fColl->CreateTH1F("h_Kaon", "all Kaon candidates (no MC); p (GeV/c); counts",  nBins, pMin, pMax, 0);
  74   fColl->CreateTH1F("h_Proton", "all Lambda proton candidates (no MC); p (GeV/c); counts",  nBins, pMin, pMax, 0);
  75
  76   fColl->CreateTH1F("h_mis_Electron", "all NON electron candidates MC tagged; p (GeV/c); counts",  nBins, pMin, pMax, 0);
  77   fColl->CreateTH1F("h_mis_PionK0", "all NON K0 pion candidates MC tagged; p (GeV/c); counts",  nBins, pMin, pMax, 0);
  78   fColl->CreateTH1F("h_mis_PionL", "all NON Lambda pion candidates MC tagged ; p (GeV/c); counts", nBins, pMin, pMax, 0);
  79   fColl->CreateTH1F("h_mis_Kaon", "all NON Kaon candidates MC tagged; p (GeV/c); counts", nBins, pMin, pMax, 0);
  80   fColl->CreateTH1F("h_mis_Proton", "all NON Lambda proton candidates MC tagged; p (GeV/c); counts", nBins, pMin, pMax, 0);
  81
  82   fColl->CreateTH1Fvector1(5, "h_tag_Electron", "electron candidate MC tagged; p (GeV/c); counts", nBins, pMin, pMax, 0);
  83   fColl->CreateTH1Fvector1(5, "h_tag_PionK0", "K0 pion candidate MC tagged; p (GeV/c); counts", nBins, pMin, pMax, 0);
  84   fColl->CreateTH1Fvector1(5, "h_tag_PionL", "Lambda pion candidate MC tagged; p (GeV/c); counts", nBins, pMin, pMax, 0);
  85   fColl->CreateTH1Fvector1(5, "h_tag_Kaon", "kaon candidate MC tagged; p (GeV/c); counts", nBins, pMin, pMax, 0);
  86   fColl->CreateTH1Fvector1(5, "h_tag_Proton", "Lambda proton candidate MC tagged; p (GeV/c); counts", nBins, pMin, pMax, 0);
  87
  88 }
  89 //____________________________________________________________
  90 Bool_t  AliHFEV0pidMC::Process(TObjArray * const particles, Int_t type){
  91   //
  92   // process the selected V0 daughter tracks
  93   //
  94
  95   Char_t hname[256] = "";
  96   const Char_t *typeName[5] = {"Electron", "PionK0", "PionL", "Kaon", "Proton"};
  97   const Int_t  typePID[5] = {0, 2, 2, 3, 4};
  98
  99   if(!fMC) return kFALSE;
 100   if(!particles) return kFALSE;
 101
 102   AliVParticle *recTrack = NULL;
 103   TIterator *trackIter = particles->MakeIterator();
 104   while((recTrack = dynamic_cast<AliVParticle *>(trackIter->Next()))){
 105     fColl->Fill("h_QA_nParticles", 0);
 106     // only ESD for now
 107     AliESDtrack *track = dynamic_cast<AliESDtrack *>(recTrack);
 108     const AliExternalTrackParam *ext = track->GetOuterParam();
 109     if(!ext) continue;
 110     // MC label
 111     Int_t label = track->GetLabel();
 112     if(label <0){
 113        fColl->Fill("h_QA_nParticles", 1);
 114       continue;
 115     }
 116     AliMCParticle *mcpD = dynamic_cast<AliMCParticle*>(fMC->GetTrack(label));
 117     if(!mcpD){
 118       fColl->Fill("h_QA_nParticles", 2);
 119       continue;
 120     }
 121
 122     Float_t p = ext->P();
 123     //Short_t charge = ext->Charge();
 124     Int_t pdgD = mcpD->PdgCode();
 125     AliMCParticle *mcpM = dynamic_cast<AliMCParticle*>(fMC->GetTrack(mcpD->GetMother()));
 126     if(!mcpM){
 127       fColl->Fill("h_QA_nParticles", 3);
 128       continue;
 129     }
 130     //Int_t pdgM = mcpM->PdgCode();
 131
 132     // all candidates
 133     sprintf(hname, "h_%s", typeName[type]);
 134     fColl->Fill(hname, p);
 135     Int_t pidD = PDGtoPIDdaughter(pdgD);
 136
 137     // all misidentified candidates
 138     sprintf(hname, "h_mis_%s", typeName[type]);
 139     if(typePID[type] != pidD){
 140       fColl->Fill(hname, p);
 141     }
 142
 143     // for every particle fill detailed information about the missidentified particles
 144     sprintf(hname, "h_tag_%s", typeName[type]);
 145     Int_t aliPID = PDGtoAliPID(pdgD);
 146     fColl->Fill(hname, aliPID, p);
 147
 148   }// .. loop over array
 149
 150
 151   return kTRUE;
 152 }
 153 //____________________________________________________________
 154 Int_t AliHFEV0pidMC::PDGtoPIDdaughter(Int_t pdg) const {
 155   //
 156   // convert PDG to local pid
 157   //
 158   switch (TMath::Abs(pdg)){
 159   case 11:
 160     return 0;  // electron gamma
 161   case 211:
 162     return 2; // pion K0 or pion Lambda
 163   case 321:
 164     return 3; //kaon Phi
 165   case 2212:
 166     return 4; // proton Lambda
 167   default:
 168     return -1;
 169   };
 170
 171   return -1;
 172 }
 173 //____________________________________________________________
 174 Int_t AliHFEV0pidMC::PDGtoPIDmother(Int_t pdg) const {
 175   //
 176   // convert PDG to local pid
 177   //
 178   switch (TMath::Abs(pdg)){
 179   case 22:
 180       return 0; // gamma
 181     case 310:
 182     return 1; // K0s
 183   case 333:
 184     return 2; // Phi
 185   case 3122:
 186     return 3; // Lambda
 187   default:
 188     return -1;
 189   };
 190
 191   return -1;
 192 }
 193 //____________________________________________________________
 194 Int_t AliHFEV0pidMC::PDGtoAliPID(Int_t pdg) const {
 195   //
 196   // convert PDG to AliPID
 197   //
 198
 199   switch (TMath::Abs(pdg)){
 200   case 11:
 201     return 0; // electron
 202   case 13:
 203     return 1; // muon
 204   case 211:
 205     return 2; // pion
 206   case 321:
 207     return 3; // kaon
 208   case 2212:
 209     return 4; // proton
 210   default:
 211     return -1;
 212   };
 213   return -1;
 214 }
 215