[u/mrichter/AliRoot.git] / PWG3 / hfe / AliHFEV0pidMC.cxx

/**************************************************************************
* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
*                                                                        *
* Author: The ALICE Off-line Project.                                    *
* Contributors are mentioned in the code where appropriate.              *
*                                                                        *
* Permission to use, copy, modify and distribute this software and its   *
* documentation strictly for non-commercial purposes is hereby granted   *
* without fee, provided that the above copyright notice appears in all   *
* copies and that both the copyright notice and this permission notice   *
* appear in the supporting documentation. The authors make no claims     *
* about the suitability of this software for any purpose. It is          *
* provided "as is" without express or implied warranty.                  *
**************************************************************************/
//
// class to benchmark the V0 pid capabilties
// runs over reconstructed V0 candidates and uses MC information for 
// further analysis [purity, PID perfortmance]
//
// authors:
//    Matus Kalisky <matus.kalisky@cern.ch>
//

#include "TIterator.h"

#include "AliVParticle.h"
#include "AliESDtrack.h"
#include "AliMCParticle.h"
#include "AliMCEvent.h"

#include "AliHFEcollection.h"

#include "AliHFEV0pidMC.h"
ClassImp(AliHFEV0pidMC)

//____________________________________________________________
  AliHFEV0pidMC::AliHFEV0pidMC():
    fMC(0x0)
    , fColl(NULL)
    , fV0cuts(NULL)
{
  //
  // default constructor
  //

}
//____________________________________________________________
AliHFEV0pidMC::~AliHFEV0pidMC(){
  //
  // destructor
  //
  if (fColl) delete fColl;
  //if (fV0cuts) delete fV0cuts;
}
//____________________________________________________________
void AliHFEV0pidMC::Init(){
  //
  // initialize objects
  //

  fColl = new AliHFEcollection("V0pidMC", "MC based V0 benchmarking");
  // QA
  fColl->CreateTH1F("h_QA_nParticles", "QA on track processing", 10, -0.5, 9.5);

  const Int_t nBins = 20;
  const Float_t pMin = 0.1;
  const Float_t pMax = 10.;

  // before PID
  fColl->CreateTH1F("h_Electron", "all electron candidates (no MC); p (GeV/c); counts", nBins, pMin, pMax, 0);
  fColl->CreateTH1F("h_PionK0", "all K0 pion candidates (no MC); p (GeV/c); counts",  nBins, pMin, pMax, 0);
  fColl->CreateTH1F("h_PionL", "all Lambda pion candidates (no MC); p (GeV/c); counts", nBins, pMin, pMax, 0);
  fColl->CreateTH1F("h_Kaon", "all Kaon candidates (no MC); p (GeV/c); counts",  nBins, pMin, pMax, 0);
  fColl->CreateTH1F("h_Proton", "all Lambda proton candidates (no MC); p (GeV/c); counts",  nBins, pMin, pMax, 0);
  
  fColl->CreateTH1F("h_mis_Electron", "all NON electron candidates MC tagged; p (GeV/c); counts",  nBins, pMin, pMax, 0);
  fColl->CreateTH1F("h_mis_PionK0", "all NON K0 pion candidates MC tagged; p (GeV/c); counts",  nBins, pMin, pMax, 0);
  fColl->CreateTH1F("h_mis_PionL", "all NON Lambda pion candidates MC tagged ; p (GeV/c); counts", nBins, pMin, pMax, 0);
  fColl->CreateTH1F("h_mis_Kaon", "all NON Kaon candidates MC tagged; p (GeV/c); counts", nBins, pMin, pMax, 0);
  fColl->CreateTH1F("h_mis_Proton", "all NON Lambda proton candidates MC tagged; p (GeV/c); counts", nBins, pMin, pMax, 0);  

  fColl->CreateTH1Fvector1(5, "h_tag_Electron", "electron candidate MC tagged; p (GeV/c); counts", nBins, pMin, pMax, 0);
  fColl->CreateTH1Fvector1(5, "h_tag_PionK0", "K0 pion candidate MC tagged; p (GeV/c); counts", nBins, pMin, pMax, 0);
  fColl->CreateTH1Fvector1(5, "h_tag_PionL", "Lambda pion candidate MC tagged; p (GeV/c); counts", nBins, pMin, pMax, 0);
  fColl->CreateTH1Fvector1(5, "h_tag_Kaon", "kaon candidate MC tagged; p (GeV/c); counts", nBins, pMin, pMax, 0);
  fColl->CreateTH1Fvector1(5, "h_tag_Proton", "Lambda proton candidate MC tagged; p (GeV/c); counts", nBins, pMin, pMax, 0);

}
//____________________________________________________________
Bool_t  AliHFEV0pidMC::Process(TObjArray * const particles, Int_t type){
  //
  // process the selected V0 daughter tracks
  //
  
  Char_t hname[256] = "";
  const Char_t *typeName[5] = {"Electron", "PionK0", "PionL", "Kaon", "Proton"};
  const Int_t  typePID[5] = {0, 2, 2, 3, 4};

  if(!fMC) return kFALSE;
  if(!particles) return kFALSE;
  
  AliVParticle *recTrack = NULL;
  TIterator *trackIter = particles->MakeIterator(); 
  while((recTrack = dynamic_cast<AliVParticle *>(trackIter->Next()))){
    fColl->Fill("h_QA_nParticles", 0);
    // only ESD for now
    AliESDtrack *track = dynamic_cast<AliESDtrack *>(recTrack);
    const AliExternalTrackParam *ext = track->GetOuterParam();
    if(!ext) continue;
    // MC label
    Int_t label = track->GetLabel();
    if(label <0){
       fColl->Fill("h_QA_nParticles", 1);
      continue;
    }
    AliMCParticle *mcpD = dynamic_cast<AliMCParticle*>(fMC->GetTrack(label));
    if(!mcpD){
      fColl->Fill("h_QA_nParticles", 2);
      continue;
    }

    Float_t p = ext->P();
    //Short_t charge = ext->Charge();
    Int_t pdgD = mcpD->PdgCode();
    AliMCParticle *mcpM = dynamic_cast<AliMCParticle*>(fMC->GetTrack(mcpD->GetMother()));
    if(!mcpM){
      fColl->Fill("h_QA_nParticles", 3);
      continue;
    }
    //Int_t pdgM = mcpM->PdgCode();

    // all candidates
    sprintf(hname, "h_%s", typeName[type]);
    fColl->Fill(hname, p);
    Int_t pidD = PDGtoPIDdaughter(pdgD);
    
    // all misidentified candidates
    sprintf(hname, "h_mis_%s", typeName[type]);
    if(typePID[type] != pidD){
      fColl->Fill(hname, p);
    }

    // for every particle fill detailed information about the missidentified particles
    sprintf(hname, "h_tag_%s", typeName[type]);       
    Int_t aliPID = PDGtoAliPID(pdgD);
    fColl->Fill(hname, aliPID, p);
    
  }// .. loop over array
  
  
  return kTRUE;
}  
//____________________________________________________________
Int_t AliHFEV0pidMC::PDGtoPIDdaughter(Int_t pdg) const {
  //
  // convert PDG to local pid 
  //
  switch (TMath::Abs(pdg)){
  case 11:
    return 0;  // electron gamma
  case 211:
    return 2; // pion K0 or pion Lambda
  case 321:
    return 3; //kaon Phi
  case 2212:
    return 4; // proton Lambda
  default:
    return -1;
  };
  
  return -1;
}
//____________________________________________________________
Int_t AliHFEV0pidMC::PDGtoPIDmother(Int_t pdg) const {
  //
  // convert PDG to local pid
  //
  switch (TMath::Abs(pdg)){
  case 22:
      return 0; // gamma
    case 310: 
    return 1; // K0s
  case 333:
    return 2; // Phi
  case 3122:
    return 3; // Lambda
  default:
    return -1;
  };
  
  return -1;
}
//____________________________________________________________
Int_t AliHFEV0pidMC::PDGtoAliPID(Int_t pdg) const {
  //
  // convert PDG to AliPID
  //
  
  switch (TMath::Abs(pdg)){
  case 11:
    return 0; // electron 
  case 13:
    return 1; // muon
  case 211:
    return 2; // pion 
  case 321:
    return 3; // kaon 
  case 2212:
    return 4; // proton 
  default:
    return -1;
  };
  return -1;
}
Commit	Line	Data
70da6c5a	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
70da6c5a	26	#include "AliVParticle.h"
	27	#include "AliESDtrack.h"
	28	#include "AliMCParticle.h"
faee3b18	29	#include "AliMCEvent.h"
	30
	31	#include "AliHFEcollection.h"
70da6c5a	32
	33	#include "AliHFEV0pidMC.h"
	34	ClassImp(AliHFEV0pidMC)
	35
	36	//____________________________________________________________
	37	AliHFEV0pidMC::AliHFEV0pidMC():
	38	fMC(0x0)
faee3b18	39	, fColl(NULL)
faee3b18	40	, fV0cuts(NULL)
70da6c5a	41	{
	42	//
	43	// default constructor
	44	//
faee3b18	45
70da6c5a	46	}
	47	//____________________________________________________________
	48	AliHFEV0pidMC::~AliHFEV0pidMC(){
	49	//
	50	// destructor
	51	//
faee3b18	52	if (fColl) delete fColl;
faee3b18	53	//if (fV0cuts) delete fV0cuts;
70da6c5a	54	}
	55	//____________________________________________________________
	56	void AliHFEV0pidMC::Init(){
	57	//
	58	// initialize objects
	59	//
faee3b18	60
70da6c5a	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
3a72645a	65	const Int_t nBins = 20;
	66	const Float_t pMin = 0.1;
	67	const Float_t pMax = 10.;
	68
70da6c5a	69	// before PID
3a72645a	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);
70da6c5a	75
3a72645a	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);
70da6c5a	81
3a72645a	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);
70da6c5a	87
70da6c5a	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();
faee3b18	131
70da6c5a	132	// all candidates
	133	sprintf(hname, "h_%s", typeName[type]);
	134	fColl->Fill(hname, p);
	135	Int_t pidD = PDGtoPIDdaughter(pdgD);
	136
faee3b18	137	// all misidentified candidates
70da6c5a	138	sprintf(hname, "h_mis_%s", typeName[type]);
	139	if(typePID[type] != pidD){
	140	fColl->Fill(hname, p);
	141	}
70da6c5a	142
faee3b18	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);
70da6c5a	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	}
faee3b18	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