Various updates, including corrections for code rule violations
authorsma <sma@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 16 Dec 2010 09:14:09 +0000 (09:14 +0000)
committersma <sma@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 16 Dec 2010 09:14:09 +0000 (09:14 +0000)
46 files changed:
PWG3/hfe/AliAnalysisTaskCheckV0tenderII.cxx
PWG3/hfe/AliAnalysisTaskCheckV0tenderII.h
PWG3/hfe/AliAnalysisTaskDCA.cxx
PWG3/hfe/AliAnalysisTaskDisplacedElectrons.cxx
PWG3/hfe/AliAnalysisTaskDisplacedElectrons.h
PWG3/hfe/AliAnalysisTaskHFE.cxx
PWG3/hfe/AliAnalysisTaskHFE.h
PWG3/hfe/AliHFEcontainer.cxx
PWG3/hfe/AliHFEcontainer.h
PWG3/hfe/AliHFEdca.cxx
PWG3/hfe/AliHFEdca.h
PWG3/hfe/AliHFEdetPIDqa.cxx
PWG3/hfe/AliHFEdetPIDqa.h
PWG3/hfe/AliHFEdisplacedElectrons.cxx
PWG3/hfe/AliHFEdisplacedElectrons.h
PWG3/hfe/AliHFEpid.cxx
PWG3/hfe/AliHFEpid.h
PWG3/hfe/AliHFEpidBase.h
PWG3/hfe/AliHFEpidITS.cxx
PWG3/hfe/AliHFEpidITS.h
PWG3/hfe/AliHFEpidMC.cxx
PWG3/hfe/AliHFEpidMC.h
PWG3/hfe/AliHFEpidQA.cxx
PWG3/hfe/AliHFEpidQA.h
PWG3/hfe/AliHFEpidQAmanager.cxx
PWG3/hfe/AliHFEpidQAmanager.h
PWG3/hfe/AliHFEpidTOF.cxx
PWG3/hfe/AliHFEpidTOF.h
PWG3/hfe/AliHFEpidTPC.cxx
PWG3/hfe/AliHFEpidTPC.h
PWG3/hfe/AliHFEpidTRD.cxx
PWG3/hfe/AliHFEpidTRD.h
PWG3/hfe/AliHFEspectrum.cxx
PWG3/hfe/AliHFEspectrum.h
PWG3/hfe/AliHFEtaggedTrackAnalysis.cxx
PWG3/hfe/AliHFEtaggedTrackAnalysis.h
PWG3/hfe/AliHFEtofPIDqa.cxx
PWG3/hfe/AliHFEtofPIDqa.h
PWG3/hfe/AliHFEtpcPIDqa.cxx
PWG3/hfe/AliHFEtpcPIDqa.h
PWG3/hfe/AliHFEtrackFilter.h
PWG3/hfe/AliHFEtrdPIDqa.cxx
PWG3/hfe/AliHFEtrdPIDqaV1.cxx
PWG3/hfe/AliHFEtrdPIDqaV1.h
PWG3/hfe/AliHFEvarManager.cxx
PWG3/hfe/AliHFEvarManager.h

index 9fe9060..9899d96 100644 (file)
@@ -16,7 +16,7 @@
 // Task fir checking the performance of the V0 tender
 // 
 // 
-// Authors
+// Authors:
 //   Matus Kalisky <matus.kalisky@cern.ch>
 //
 
@@ -473,7 +473,7 @@ Bool_t AliAnalysisTaskCheckV0tenderII::CheckSigns(AliESDv0 * const v0){
   return correct;
 }
 //__________________________________________________________
-const Int_t  AliAnalysisTaskCheckV0tenderII::PDGtoPIDv0(Int_t pdgV0){
+Int_t  AliAnalysisTaskCheckV0tenderII::PDGtoPIDv0(Int_t pdgV0) const {
   //
   // convert thereconstructed V0 pdg to local pid
   //
@@ -489,7 +489,7 @@ const Int_t  AliAnalysisTaskCheckV0tenderII::PDGtoPIDv0(Int_t pdgV0){
 
 }
 //__________________________________________________________
-const Int_t  AliAnalysisTaskCheckV0tenderII::PDGtoPID(Int_t pdg){
+Int_t  AliAnalysisTaskCheckV0tenderII::PDGtoPID(Int_t pdg) const {
   //
   // convert daughter pdg code to local pid
   //
index 5563d7a..8594227 100644 (file)
@@ -67,8 +67,8 @@ class AliAnalysisTaskCheckV0tenderII : public AliAnalysisTaskSE{
   Float_t MassV0(AliESDv0 * const v0, Int_t id);
   Bool_t  CheckSigns(AliESDv0 * const v0);
 
-  const Int_t   PDGtoPIDv0(Int_t pdgV0);
-  const Int_t   PDGtoPID(Int_t pdg);
+  Int_t   PDGtoPIDv0(Int_t pdgV0) const;
+  Int_t   PDGtoPID(Int_t pdg) const;
   
 
   TList              *fOutput;        //! Container for output histos
@@ -87,4 +87,5 @@ class AliAnalysisTaskCheckV0tenderII : public AliAnalysisTaskSE{
 
 };
 
+
 #endif
index 3fee448..4ecc82b 100644 (file)
@@ -22,6 +22,7 @@
 //  Hongyan Yang <hongyan@physi.uni-heidelberg.de>
 //  Carlo Bombonati <carlo.bombonati@cern.ch>
 //
+#include <Riostream.h>
 #include <TChain.h>
 #include <TFile.h>
 #include <TH1F.h>
@@ -51,6 +52,7 @@
 #include "AliHFEpid.h"
 #include "AliHFEcuts.h"
 #include "AliHFEdca.h"
+#include "AliHFEtools.h"
 
 #include "AliAnalysisTaskDCA.h"
 
@@ -90,8 +92,10 @@ AliAnalysisTaskDCA::AliAnalysisTaskDCA():
   DefineOutput(1, TH1I::Class());
   DefineOutput(2, TList::Class());
 
-  fDefaultPID = new AliESDpid;
-  fHFEpid = new AliHFEpid("PIDforDCAanalysis");
+  printf(" ---> Dummy constructor used!\n"); 
+  AliInfo("Dummy constructor used!");
+  fDefaultPID = new AliESDpid();
+  fHFEpid = new AliHFEpid("dummyPID");
 
 }
 
@@ -129,8 +133,25 @@ AliAnalysisTaskDCA::AliAnalysisTaskDCA(const char * name):
   DefineInput(0, TChain::Class());
   DefineOutput(1, TH1I::Class());
   DefineOutput(2, TList::Class());
-  
-  fDefaultPID = new AliESDpid;
+
+
+  //-CUTS SETTING-//
+  Int_t nMinTPCcluster = 100;
+  Float_t maxDcaXY = 0.5;
+  Float_t maxDcaZ = 1.0;
+  //--------------//
+  AliHFEcuts *hfecuts = new AliHFEcuts;
+  hfecuts->CreateStandardCuts();
+  hfecuts->SetMinNClustersTPC(nMinTPCcluster);
+  hfecuts->SetCutITSpixel(AliHFEextraCuts::kFirst);
+  hfecuts->SetCheckITSLayerStatus(kFALSE);
+  hfecuts->SetMaxImpactParam(maxDcaXY, maxDcaZ);
+  SetHFECuts(hfecuts);
+
+  printf(" ---> Default constructor used!\n");  
+  cout<<" [!] DEFAULT CONSTRUCTOR! [!]"<<endl;
+  AliInfo(" ---> Default constructor used!");  
+  fDefaultPID = new AliESDpid();
   fHFEpid = new AliHFEpid("PIDforDCAanalysis");
 
 }
@@ -166,7 +187,7 @@ AliAnalysisTaskDCA::AliAnalysisTaskDCA(const AliAnalysisTaskDCA &ref):
   //
   // Copy Constructor
   //
-
+  AliInfo("Copy Constructor");
   ref.Copy(*this);
 }
 
@@ -285,6 +306,7 @@ void AliAnalysisTaskDCA::UserCreateOutputObjects(){
   // create output objects
   // fNEvents
   // residual and pull
+  printf("\n=====UserCreateOutputObjects=====\n");
   
   // Automatic determination of the analysis mode
   AliVEventHandler *inputHandler = dynamic_cast<AliVEventHandler *>(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler());
@@ -318,11 +340,16 @@ void AliAnalysisTaskDCA::UserCreateOutputObjects(){
   
   fCuts->Initialize(fCFM);
   
-  if(!fHFEpid) printf("hallo, fHFEpid is not available\n");
-  
-  if(fHFEpid && GetPlugin(kHFEpid)) {      
+  if(!fHFEpid) AliWarning("Hello, fHFEpid is not available");
+  cout<<"  Hello this is a cout "<<endl<<endl;
+
+  if(GetPlugin(kHFEpid)) {  
+    AliWarning(" ---> Adding TPC and TOF to the PID");  
     fHFEpid->SetHasMCData(HasMCData());
-    fHFEpid->AddDetector("TPC", 0);
+    fHFEpid->AddDetector("TOF", 0);
+    fHFEpid->AddDetector("TPC", 1);
+    cout<<endl<<" ---> TPC and TOF added to the PID"<<endl;
+    fHFEpid->ConfigureTPCrejection();
     fHFEpid->InitializePID();
   }
 
@@ -357,15 +384,15 @@ void AliAnalysisTaskDCA::UserCreateOutputObjects(){
       fDCA->CreateHistogramsKfDca(fKfDcaList);
       fOutput->AddAt(fDcaList,3);
     }
-    if(GetPlugin(kPrimVtx)){
+    if(GetPlugin(kPrimVtx)){//<---
       fDCA->CreateHistogramsVertex(fMcVertexList);
       fOutput->AddAt(fMcVertexList,4);
     }
-    if(GetPlugin(kCombinedPid)){
+    if(GetPlugin(kCombinedPid)){//<---
       fDCA->CreateHistogramsPid(fMcPidList);
       fOutput->AddAt(fMcPidList, 5);
     }
-    if(GetPlugin(kHFEpid)){
+    if(GetPlugin(kHFEpid)){//<---
       fDCA->CreateHistogramsHfeDca(fHfeDcaList);
       fOutput->AddAt(fHfeDcaList, 6);
     }
@@ -402,6 +429,8 @@ void AliAnalysisTaskDCA::UserExec(Option_t *){
   //
   // Run the analysis
   // 
+  printf("\n=====UserExec=====\n");
+  if(HasMCData()) printf("WITH MC!\n");
 
   AliDebug(3, "Processing ESD events");
 
@@ -448,7 +477,7 @@ void AliAnalysisTaskDCA::UserExec(Option_t *){
       fHFEpid->SetESDpid(workingPID);
     } else {
       AliDebug(1, "Using default ESD PID");
-      fHFEpid->SetESDpid(fDefaultPID);
+      fHFEpid->SetESDpid(AliHFEtools::GetDefaultPID(HasMCData()));
     }
     ProcessDcaAnalysis();
   }
@@ -460,11 +489,14 @@ void AliAnalysisTaskDCA::UserExec(Option_t *){
 //____________________________________________________________
 void AliAnalysisTaskDCA::ProcessDcaAnalysis(){
 
+  printf("\n=====ProcessDcaAnalysis=====\n");
+
   //
   // Loop ESD
   //
   
   AliMCEvent *fMC = 0x0;
+  AliESDVertex *vtxESDSkip = 0x0;
 
   AliESDEvent *fESD = dynamic_cast<AliESDEvent *>(fInputEvent);
   if(!fESD){
@@ -522,9 +554,25 @@ void AliAnalysisTaskDCA::ProcessDcaAnalysis(){
        fDCA->FillHistogramsKfDca(fESD, track, fMC);
       if(GetPlugin(kCombinedPid)) 
        fDCA->FillHistogramsPid(track, fMC);
-      if(GetPlugin(kHFEpid)) {
+      if(GetPlugin(kHFEpid)) { // data-like
        if(fHFEpid->IsSelected(&hfetrack)) 
-         fDCA->FillHistogramsHfeDca(fESD, track, fMC);
+
+         //      printf("Found an electron in p+p collision! from HFE pid \n");
+         if(!vtxESDSkip){
+           // method from Andrea D 28.05.2010
+           AliVertexerTracks *vertexer = new AliVertexerTracks(fESD->GetMagneticField());
+           vertexer->SetITSMode();
+           vertexer->SetMinClusters(fNclustersITS);
+           Int_t skipped[2];
+           skipped[0] = (Int_t)track->GetID();
+           vertexer->SetSkipTracks(1,skipped);
+           vtxESDSkip = (AliESDVertex*)vertexer->FindPrimaryVertex(fESD);
+           delete vertexer; vertexer = NULL;
+           if(vtxESDSkip->GetNContributors()<fMinNprimVtxContrbutor) continue;
+         }
+
+         fDCA->FillHistogramsHfeDataDca(fESD, track,vtxESDSkip); 
+
       } // plugin for hfepid 
     }  // MC
 
@@ -540,7 +588,7 @@ void AliAnalysisTaskDCA::ProcessDcaAnalysis(){
        Int_t skipped[2];
        skipped[0] = (Int_t)track->GetID();
        vertexer->SetSkipTracks(1,skipped);
-       AliESDVertex *vtxESDSkip = (AliESDVertex*)vertexer->FindPrimaryVertex(fESD);
+       vtxESDSkip = (AliESDVertex*)vertexer->FindPrimaryVertex(fESD);
        delete vertexer; vertexer = NULL;
        if(vtxESDSkip->GetNContributors()<fMinNprimVtxContrbutor) continue;
 
@@ -550,7 +598,20 @@ void AliAnalysisTaskDCA::ProcessDcaAnalysis(){
       if(GetPlugin(kHFEpid)) {
        if(fHFEpid->IsSelected(&hfetrack)) {
          //      printf("Found an electron in p+p collision! from HFE pid \n");
-         fDCA->FillHistogramsHfeDataDca(fESD, track);    
+         if(!vtxESDSkip){
+           // method from Andrea D 28.05.2010
+           AliVertexerTracks *vertexer = new AliVertexerTracks(fESD->GetMagneticField());
+           vertexer->SetITSMode();
+           vertexer->SetMinClusters(fNclustersITS);
+           Int_t skipped[2];
+           skipped[0] = (Int_t)track->GetID();
+           vertexer->SetSkipTracks(1,skipped);
+           vtxESDSkip = (AliESDVertex*)vertexer->FindPrimaryVertex(fESD);
+           delete vertexer; vertexer = NULL;
+           if(vtxESDSkip->GetNContributors()<fMinNprimVtxContrbutor) continue;
+         }
+
+         fDCA->FillHistogramsHfeDataDca(fESD, track,vtxESDSkip);    
        } 
       } // plugin for hfepid
     }  // data case
@@ -565,6 +626,7 @@ void AliAnalysisTaskDCA::Terminate(Option_t *){
   //
   // Terminate not implemented at the moment
   //  
+  printf("\n=====Terminate=====\n");
   
   if(GetPlugin(kPostProcess)){
     fOutput = dynamic_cast<TList *>(GetOutputData(1));
@@ -580,6 +642,9 @@ void AliAnalysisTaskDCA::Terminate(Option_t *){
 
 //____________________________________________________________
 void AliAnalysisTaskDCA::Load(TString filename){
+
+  printf("\n=====Load=====\n");
+
   // no need for postprocessing for the moment
   TFile *input = TFile::Open(filename.Data());
   if(!input || input->IsZombie()){
@@ -599,6 +664,7 @@ void AliAnalysisTaskDCA::PostProcess(){
   // should do fitting here for dca resolution
   // moved to an external macro to do the job
   
+  printf("\n=====PostProcess=====\n");
   Load("HFEdca.root");
   TCanvas *c1 = new TCanvas("c1", "number of analyzed events", 300, 400);
   fNEvents->Draw();
@@ -634,8 +700,10 @@ void AliAnalysisTaskDCA::SwitchOnPlugin(Int_t plug){
   // Switch on Plugin          
   // Available:                                  
   //  - analyze impact parameter
-  //  - Post Processing                                                                      
-  
+  //  - Post Processing  
+
+  AliDebug(2,Form("SwitchOnPlugin %d",plug));  
+
   switch(plug){
   case kPostProcess: 
     SETBIT(fPlugins, plug); 
@@ -663,6 +731,8 @@ void AliAnalysisTaskDCA::SwitchOnPlugin(Int_t plug){
 
 //____________________________________________________________
 void AliAnalysisTaskDCA::MakeParticleContainer(){
+
+  printf("\n=====MakeParticleContainer=====\n");
   //
   // Create the particle container (borrowed from AliAnalysisTaskHFE)
   //
@@ -715,6 +785,7 @@ void AliAnalysisTaskDCA::AddPIDdetector(TString detector){
   //
   // Adding PID detector to the task
   //
+  printf("\n=====AddPIDdetector=====\n");
   
   if(!fPIDdetectors.Length()) 
     fPIDdetectors = detector;
index f302ebf..778456a 100644 (file)
@@ -231,15 +231,15 @@ void AliAnalysisTaskDisplacedElectrons::UserCreateOutputObjects(){
   fElectronsMcPt = new TH1F("mcElectronPt", "MC: p_{T} distribution of identified electrons (mcpid);p_{T} (GeV/c);Counts;", nBins-1, ptBins); 
   fElectronsEsdPt = new TH1F("esdElectronPt", "ESD: p_{T} distribution of identified electrons (hfepid);p_{T} (GeV/c);Counts;", nBins-1, ptBins); 
   fElectronsDataPt = new TH1F("dataElectronPt", "DATA: p_{T} distribution of identified electrons (hfepid);p_{T} (GeV/c);Counts;", nBins-1, ptBins); 
-  
+
   fDeQA->AddAt(fDeNEvents,0);
   if(HasMCData()){
     fDeQA->AddAt(fElectronsMcPt, 1);
-    fDeQA->AddAt(fElectronsEsdPt, 2);  
+    fDeQA->AddAt(fElectronsEsdPt, 2); 
   }
-  else
+  else{
     fDeQA->AddAt(fElectronsDataPt, 1);  
-  
+  }
   // Initialize correction Framework and Cuts
   fDeCFM = new AliCFManager;
   MakeEventContainer();
@@ -467,7 +467,7 @@ void AliAnalysisTaskDisplacedElectrons::ProcessESD(){
   Double_t nContrib = fESD->GetPrimaryVertex()->GetNContributors();
 
   Bool_t alreadyseen = kFALSE;
-  LabelContainer cont(fESD->GetNumberOfTracks());
+  AliLabelContainer cont(fESD->GetNumberOfTracks());
   
   Int_t nHFEelectrons = 0;  
   AliESDtrack *track = 0x0;    
@@ -567,7 +567,7 @@ void AliAnalysisTaskDisplacedElectrons::ProcessData(){
   memset(dataContainer, 0, sizeof(Double_t) * 4);
   
   Bool_t alreadyseen = kFALSE;
-  LabelContainer cont(fESD->GetNumberOfTracks());
+  AliLabelContainer cont(fESD->GetNumberOfTracks());
 
 
   AliESDtrack *track = 0x0;
@@ -813,7 +813,7 @@ void AliAnalysisTaskDisplacedElectrons::AddPIDdetector(TString detector){
 
 
 //____________________________________________________________
-AliAnalysisTaskDisplacedElectrons::LabelContainer::LabelContainer(Int_t capacity):
+AliAnalysisTaskDisplacedElectrons::AliLabelContainer::AliLabelContainer(Int_t capacity):
   fContainer(NULL),
   fBegin(NULL),
   fEnd(NULL),
@@ -830,7 +830,7 @@ AliAnalysisTaskDisplacedElectrons::LabelContainer::LabelContainer(Int_t capacity
 }
 
 //____________________________________________________________
-Bool_t AliAnalysisTaskDisplacedElectrons::LabelContainer::Append(Int_t label){
+Bool_t AliAnalysisTaskDisplacedElectrons::AliLabelContainer::Append(Int_t label){
   //
   // Add Label to the container
   //
@@ -840,7 +840,7 @@ Bool_t AliAnalysisTaskDisplacedElectrons::LabelContainer::Append(Int_t label){
 }
 
 //____________________________________________________________
-Bool_t AliAnalysisTaskDisplacedElectrons::LabelContainer::Find(Int_t label) const {
+Bool_t AliAnalysisTaskDisplacedElectrons::AliLabelContainer::Find(Int_t label) const {
   //
   // Find track in the list of labels
   //
@@ -850,10 +850,11 @@ Bool_t AliAnalysisTaskDisplacedElectrons::LabelContainer::Find(Int_t label) cons
 }
 
 //____________________________________________________________
-Int_t AliAnalysisTaskDisplacedElectrons::LabelContainer::Next() { 
+Int_t AliAnalysisTaskDisplacedElectrons::AliLabelContainer::Next() { 
   //
   // Mimic iterator
   //
   if(fCurrent > fLast) return -1; 
-  return *fCurrent++;
+  *fCurrent++;
+  return *fCurrent;
 }
index 4190d8d..eba5ac3 100644 (file)
@@ -108,10 +108,10 @@ class AliAnalysisTaskDisplacedElectrons : public AliAnalysisTaskSE{
   
  private:
   
-  class LabelContainer{
+  class AliLabelContainer{
   public:
-    LabelContainer(Int_t capacity);
-    ~LabelContainer() {delete[] fContainer; };
+    AliLabelContainer(Int_t capacity);
+    ~AliLabelContainer() {delete[] fContainer; };
     
     Bool_t Append(Int_t label);
     Bool_t Find(Int_t Label) const;
@@ -119,8 +119,8 @@ class AliAnalysisTaskDisplacedElectrons : public AliAnalysisTaskSE{
     void ResetIterator(){ fCurrent = fBegin; }
     
   private:
-    LabelContainer(const LabelContainer &);
-    LabelContainer &operator=(const LabelContainer &);
+    AliLabelContainer(const AliLabelContainer &);
+    AliLabelContainer &operator=(const AliLabelContainer &);
     Int_t *fContainer;    // the Container for the labels
     Int_t *fBegin;        // Pointer to the first entry
     Int_t *fEnd;          // Pointer to the end of the container
@@ -144,12 +144,11 @@ class AliAnalysisTaskDisplacedElectrons : public AliAnalysisTaskSE{
   AliHFEpid *fDePID;                      //! PID method
   AliCFManager *fDeCFM;                   //! Correction Framework Manager
   AliHFEdisplacedElectrons *fDisplacedElectrons;        //! HFE displaced Electrons pointer 
-  
-                                               
+                                
   TH1I *fDeNEvents;                       //! counter for the number of Events
   TH1F *fElectronsMcPt;                   //! pt distribution of MC electrons (mcpid)
   TH1F *fElectronsEsdPt;                  //! pt distribution of ESD electrons (hfepid)
-  TH1F *fElectronsDataPt;                  //! pt distribution of DATA electrons (hfepid)
+  TH1F *fElectronsDataPt;                 //! pt distribution of DATA electrons (hfepid)
   TList *fDeCorrection;                   //! Container for correction  Outpu  
   TList *fDeQA;                          //! container for the PID qa 
   TList *fHistDisplacedElectrons;                      //! list of outputs
index 5084850..ceda151 100644 (file)
@@ -102,6 +102,7 @@ AliAnalysisTaskHFE::AliAnalysisTaskHFE():
   , fPIDpreselect(NULL)
   , fCuts(NULL)
   , fTaggedTrackCuts(NULL)
+  , fCleanTaggedTrack(kFALSE)
   , fCutspreselect(NULL)
   , fSecVtx(NULL)
   , fElecBackGround(NULL)
@@ -141,6 +142,7 @@ AliAnalysisTaskHFE::AliAnalysisTaskHFE(const char * name):
   , fPIDpreselect(NULL)
   , fCuts(NULL)
   , fTaggedTrackCuts(NULL)
+  , fCleanTaggedTrack(kFALSE)
   , fCutspreselect(NULL)
   , fSecVtx(NULL)
   , fElecBackGround(NULL)
@@ -185,6 +187,7 @@ AliAnalysisTaskHFE::AliAnalysisTaskHFE(const AliAnalysisTaskHFE &ref):
   , fPIDpreselect(NULL)
   , fCuts(NULL)
   , fTaggedTrackCuts(NULL)
+  , fCleanTaggedTrack(ref.fCleanTaggedTrack)
   , fCutspreselect(NULL)
   , fSecVtx(NULL)
   , fElecBackGround(NULL)
@@ -238,6 +241,7 @@ void AliAnalysisTaskHFE::Copy(TObject &o) const {
   target.fPIDpreselect = fPIDpreselect;
   target.fCuts = fCuts;
   target.fTaggedTrackCuts = fTaggedTrackCuts;
+  target.fCleanTaggedTrack = fCleanTaggedTrack;
   target.fCutspreselect = fCutspreselect;
   target.fSecVtx = fSecVtx;
   target.fElecBackGround = fElecBackGround;
@@ -320,6 +324,7 @@ void AliAnalysisTaskHFE::UserCreateOutputObjects(){
   fQACollection->CreateTH1F("mccharge", "MC Charge", 200, -100, 100);
   fQACollection->CreateTH2F("radius", "Production Vertex", 100, 0.0, 5.0, 100, 0.0, 5.0);
   InitPIDperformanceQA();
+  InitContaminationQA();
   fQA->Add(fQACollection->GetList());
 
   // Initialize PID
@@ -400,6 +405,7 @@ void AliAnalysisTaskHFE::UserCreateOutputObjects(){
     AliInfo("Analysis on V0-tagged tracks enabled");
     fTaggedTrackAnalysis = new AliHFEtaggedTrackAnalysis;
     fTaggedTrackAnalysis->SetCuts(fTaggedTrackCuts);
+    fTaggedTrackAnalysis->SetClean(fCleanTaggedTrack);
     fTaggedTrackAnalysis->SetPID(fPID);
     fTaggedTrackAnalysis->InitContainer();
     fOutput->Add(fTaggedTrackAnalysis->GetContainer());
@@ -459,8 +465,6 @@ void AliAnalysisTaskHFE::UserExec(Option_t *){
   if(IsAODanalysis()){
     AliAODpidUtil *aodworkingpid = AliHFEtools::GetDefaultAODPID(HasMCData());
     fPID->SetAODpid(aodworkingpid); 
-    if(fPIDqa) fPIDqa->SetAODpid(aodworkingpid);
-    if(fTaggedTrackAnalysis) fTaggedTrackAnalysis->GetPIDqa()->SetAODpid(aodworkingpid);
     ProcessAOD();
   } else {
     AliESDInputHandler *inH = dynamic_cast<AliESDInputHandler *>(fInputHandler);
@@ -476,8 +480,6 @@ void AliAnalysisTaskHFE::UserExec(Option_t *){
       AliDebug(1, "Using ESD PID from the input handler");
     }
     fPID->SetESDpid(workingPID);
-    if(fPIDqa) fPIDqa->SetESDpid(workingPID);
-    if(fTaggedTrackAnalysis) fTaggedTrackAnalysis->GetPIDqa()->SetESDpid(workingPID);
     if(fPIDpreselect) fPIDpreselect->SetESDpid(workingPID);
 
     ProcessESD();
@@ -785,6 +787,12 @@ void AliAnalysisTaskHFE::ProcessESD(){
     // HFEcuts: Nb of tracklets TRD0
     if(!ProcessCutStep(AliHFEcuts::kStepHFEcutsTRD, track)) continue;
 
+    // Fill correlation maps before PID
+    if(signal && fContainer->GetCorrelationMatrix("correlationstepbeforePID")) {
+      //printf("Fill correlation maps before PID\n");
+      fVarManager->FillCorrelationMatrix(fContainer->GetCorrelationMatrix("correlationstepbeforePID"));
+    }
+
     if (HasMCData() && IsQAOn(kMCqa)) {
       // mc qa for after the reconstruction and pid cuts  
       AliDebug(2, "Running MC QA");
@@ -881,6 +889,12 @@ void AliAnalysisTaskHFE::ProcessESD(){
     } // end of electron background analysis
 
     if (GetPlugin(kDEstep)) { 
+      if(HasMCData()){
+        if(mctrack && (TMath::Abs(mctrack->Particle()->GetPdgCode()) != 11)){
+          fQACollection->Fill("hadronsBeforeIPcut",track->Pt());
+          fQACollection->Fill("hadronsBeforeIPcutMC",mctrack->Pt());
+        }
+      }
       // Fill Containers for impact parameter analysis
       if(!fCFM->CheckParticleCuts(AliHFEcuts::kStepHFEcutsDca + AliHFEcuts::kNcutStepsMCTrack + AliHFEcuts::kNcutStepsRecTrack,track)) continue;
       if(signal) {
@@ -889,8 +903,11 @@ void AliAnalysisTaskHFE::ProcessESD(){
         fVarManager->FillCorrelationMatrix(fContainer->GetCorrelationMatrix("correlationstepafterDE"));
       }
       if(HasMCData()){
-        if(mctrack && (TMath::Abs(mctrack->Particle()->GetPdgCode()) != 11))
+        if(mctrack && (TMath::Abs(mctrack->Particle()->GetPdgCode()) != 11)){
           fVarManager->FillContainer(fContainer, "hadronicBackground", 2, kFALSE);
+          fQACollection->Fill("hadronsAfterIPcut",track->Pt());
+          fQACollection->Fill("hadronsAfterIPcutMC",mctrack->Pt());
+        }
       }
     }
 
@@ -1129,9 +1146,9 @@ void AliAnalysisTaskHFE::MakeEventContainer(){
   // 3rd bin: Centrality class (for pp defined as 99.)
   //
   const Int_t kNvar = 3;  // number of variables on the grid: 
-  Int_t nBins[kNvar] = {120, 2, 20};
-  Double_t binMin[kNvar] = {-30. , 0., 0.};
-  Double_t binMax[kNvar] = {30., 2., 100};
+  Int_t nBins[kNvar] = {120, 2, 11};
+  Double_t binMin[kNvar] = {-30. , 0., 0.0};
+  Double_t binMax[kNvar] = {30., 2., 11.0};
 
   AliCFContainer *evCont = new AliCFContainer("eventContainer", "Container for events", AliHFEcuts::kNcutStepsEvent, kNvar, nBins);
 
@@ -1164,6 +1181,11 @@ void AliAnalysisTaskHFE::MakeParticleContainer(){
   fContainer->CreateContainer("recTrackContDEMC", "Container for displaced electron analysis with MC information", 1);
   fContainer->CreateCorrelationMatrix("correlationstepafterPID","THnSparse with correlations");
   fContainer->CreateCorrelationMatrix("correlationstepafterDE","THnSparse with correlations");
+  if(!fVarManager->IsVariableDefined("centrality")) {
+    //printf("Create the two other correlation maps\n");
+    fContainer->CreateCorrelationMatrix("correlationstepbeforePID","THnSparse with correlations");
+    fContainer->CreateCorrelationMatrix("correlationstepafterTOF","THnSparse with correlations");
+  }
 
   // Define the step names
   for(UInt_t istep = 0; istep < AliHFEcuts::kNcutStepsMCTrack; istep++){
@@ -1204,6 +1226,17 @@ void AliAnalysisTaskHFE::InitPIDperformanceQA(){
 }
 
 //____________________________________________________________
+void AliAnalysisTaskHFE::InitContaminationQA(){
+  const Double_t kPtbound[2] = {0.1, 20.};
+  Int_t iBin[1];
+  iBin[0] = 44; // bins in pt
+  fQACollection->CreateTH1F("hadronsBeforeIPcut", "Hadrons before IP cut", iBin[0], kPtbound[0], kPtbound[1], 1);
+  fQACollection->CreateTH1F("hadronsAfterIPcut", "Hadrons after IP cut", iBin[0], kPtbound[0], kPtbound[1], 1);
+  fQACollection->CreateTH1F("hadronsBeforeIPcutMC", "Hadrons before IP cut: MC p_{t}", iBin[0], kPtbound[0], kPtbound[1], 1);
+  fQACollection->CreateTH1F("hadronsAfterIPcutMC", "Hadrons after IP cut: MC p_{t} ", iBin[0],kPtbound[0], kPtbound[1], 1);
+}
+
+//____________________________________________________________
 void AliAnalysisTaskHFE::PrintStatus() const {
   //
   // Print Analysis status
@@ -1322,8 +1355,20 @@ void AliAnalysisTaskHFE::ReadCentrality() {
        return;
    }
    // Centrality
-  AliESDCentrality *esdCentrality = fESD->GetCentrality();
-  fCentralityF = esdCentrality->GetCentralityPercentile("V0M");
+   AliESDCentrality *esdCentrality = fESD->GetCentrality();
+   Float_t fCentralityF_temp = esdCentrality->GetCentralityPercentile("V0M");
+
+   if( fCentralityF_temp >=  0. && fCentralityF_temp <   5.) fCentralityF =  0;
+   else if ( fCentralityF_temp >=  5. && fCentralityF_temp <  10.) fCentralityF =  1;
+   else if ( fCentralityF_temp >= 10. && fCentralityF_temp <  20.) fCentralityF = 2;
+   else if ( fCentralityF_temp >= 20. && fCentralityF_temp <  30.) fCentralityF = 3;
+   else if ( fCentralityF_temp >= 30. && fCentralityF_temp <  40.) fCentralityF = 4;
+   else if ( fCentralityF_temp >= 40. && fCentralityF_temp <  50.) fCentralityF = 5;
+   else if ( fCentralityF_temp >= 50. && fCentralityF_temp <  60.) fCentralityF = 6;
+   else if ( fCentralityF_temp >= 60. && fCentralityF_temp <  70.) fCentralityF = 7;
+   else if ( fCentralityF_temp >= 70. && fCentralityF_temp <  80.) fCentralityF = 8;
+   else if ( fCentralityF_temp >= 80. && fCentralityF_temp <  90.) fCentralityF = 9;
+   else if ( fCentralityF_temp >= 90. && fCentralityF_temp <=100.) fCentralityF = 10;
 
   //printf("centrality %f\n",fCentralityF);
 
index 10d0f28..fbd32ac 100644 (file)
@@ -88,6 +88,7 @@ class AliAnalysisTaskHFE : public AliAnalysisTaskSE{
 
     void SetHFECuts(AliHFEcuts * const cuts) { fCuts = cuts; };
     void SetTaggedTrackCuts(AliHFEcuts * const cuts) { fTaggedTrackCuts = cuts; }
+    void SetCleanTaggedTrack(Bool_t clean) { fCleanTaggedTrack = clean; };
     void SetHFECutsPreselect(AliHFEcuts * const cuts) { fCutspreselect = cuts; };
     void SetHFEElecBackGround(AliHFEelecbackground * const elecBackGround) { fElecBackGround = elecBackGround; };
     void SetQAOn(Int_t qaLevel) { SETBIT(fQAlevel, qaLevel); };
@@ -113,6 +114,7 @@ class AliAnalysisTaskHFE : public AliAnalysisTaskSE{
     void MakeParticleContainer();
     void MakeEventContainer();
     void InitPIDperformanceQA();
+    void InitContaminationQA();
     void ProcessMC();
     void ProcessESD();
     void ProcessAOD();
@@ -138,6 +140,7 @@ class AliAnalysisTaskHFE : public AliAnalysisTaskSE{
     AliHFEpid *fPIDpreselect;             // PID oject for pre-selected tracks (without QA)
     AliHFEcuts *fCuts;                    // Cut Collection
     AliHFEcuts *fTaggedTrackCuts;         // Cut Collection for V0 tagged tracks
+    Bool_t fCleanTaggedTrack;             // Loose cleaning of the V0 tagged tracks electron
     AliHFEcuts *fCutspreselect;           // Cut Collection for pre-selected tracks
     AliHFEsecVtx *fSecVtx;                //! Secondary Vertex Analysis
     AliHFEelecbackground *fElecBackGround;//! Background analysis
index 6353b29..26900fd 100644 (file)
@@ -288,7 +288,9 @@ THnSparseF *AliHFEcontainer::GetCorrelationMatrix(const Char_t *name) const{
   //
   // Find Correlation Matrix
   //
-  return dynamic_cast<THnSparseF *>(fCorrelationMatrices->FindObject(name));
+  if(fCorrelationMatrices) return dynamic_cast<THnSparseF *>(fCorrelationMatrices->FindObject(name));
+  else return 0x0;
+
 }
 
 //__________________________________________________________________
@@ -327,7 +329,7 @@ void AliHFEcontainer::FillCFContainerStepname(const Char_t *name, const Char_t *
 }
 
 //__________________________________________________________________
-AliCFContainer *AliHFEcontainer::MakeMergedCFContainer(const Char_t *name, const Char_t *title, const Char_t* contnames){
+AliCFContainer *AliHFEcontainer::MakeMergedCFContainer(const Char_t *name, const Char_t *title, const Char_t* contnames) const {
   //
   // Merge CF Container out of several containers 
   // Container names are separated by :
index 8abea8d..e6bef21 100644 (file)
@@ -60,7 +60,7 @@ class AliHFEcontainer : public TNamed{
     THashList *GetListOfCorrelationMatrices() const { return fCorrelationMatrices; }
     void FillCFContainer(const Char_t *name, UInt_t step, Double_t *content, Double_t weight = 1.) const;
     void FillCFContainerStepname(const Char_t *name, const Char_t *step, Double_t *content, Double_t weight = 1.) const;
-    AliCFContainer *MakeMergedCFContainer(const Char_t *name, const Char_t *title, const Char_t *contnames);
+    AliCFContainer *MakeMergedCFContainer(const Char_t *name, const Char_t *title, const Char_t *contnames) const;
 
     Int_t GetNumberOfCFContainers() const;
     Int_t GetNumberOfEvents() const { return fNEvents; };
index f21ac0f..8bc4f9c 100644 (file)
@@ -257,14 +257,14 @@ AliHFEdca::~AliHFEdca()
 
  if(fStat) delete fStat;
 
- Printf("analysis done\n");
+ //Printf("analysis done\n");
 
 }
 
 //________________________________________________________________________
 void AliHFEdca::InitAnalysis(){
 
- Printf("initialize analysis\n");
+ //Printf("initialize analysis\n");
 
 }
 
@@ -307,7 +307,7 @@ void AliHFEdca::CreateHistogramsResidual(TList *residualList){
        
        if(k==0){
          fHistDcaXYRes[j][i] = new TH1F((const char*)histName, (const char*)histTitle, nBins, -maxXYBin, maxXYBin);
-         fHistDcaXYRes[j][i]->SetLineColor((const int)fgkColorPart[j]);
+         fHistDcaXYRes[j][i]->SetLineColor((int)fgkColorPart[j]);
          if(j<(kNParticles-2)){
            fHistEPDcaXYRes[j][i] = new TH1F((const char*)histEPName, (const char*)histTitle, nBins, -maxXYBin, maxXYBin);
            fHistEPDcaXYRes[j][i]->SetLineColor((int)fgkColorPart[j]);}
@@ -840,7 +840,6 @@ void AliHFEdca::FillHistogramsDca(AliESDEvent * const esdEvent, AliESDtrack * co
  Double_t covardz[3];
 
  if(!track->PropagateToDCA(primVtx,magneticField, beampiperadius, dz, covardz)) return;  // protection
- track->PropagateToDCA(primVtx,magneticField, beampiperadius, dz, covardz);
 
  AliMCParticle *mctrack = dynamic_cast<AliMCParticle *>(mcEvent->GetTrack(TMath::Abs(track->GetLabel()))); 
  if(!mctrack) return;
@@ -937,8 +936,8 @@ void AliHFEdca::FillHistogramsDca(AliESDEvent * const esdEvent, AliESDtrack * co
 }
 
 //_______________________________________________________________________________________________
-void AliHFEdca::FillHistogramsKfDca(AliESDEvent * const esdEvent, AliESDtrack * const track, AliMCEvent * const mcEvent)
-{
+void AliHFEdca::FillHistogramsKfDca(AliESDEvent * const esdEvent, AliESDtrack * const track, const AliMCEvent * const mcEvent)
+ {
  // the kKfDca plugin
 
 // filling historgams track by track
@@ -958,7 +957,6 @@ void AliHFEdca::FillHistogramsKfDca(AliESDEvent * const esdEvent, AliESDtrack *
  Double_t dz[2];   // error of dca in cm
  Double_t covardz[3];
  if(!track->PropagateToDCA(primVtx,magneticField, beampiperadius, dz, covardz)) return; // protection 
- track->PropagateToDCA(primVtx,magneticField,  beampiperadius, dz, covardz);
 
  AliMCParticle *mctrack = dynamic_cast<AliMCParticle *>(mcEvent->GetTrack(TMath::Abs(track->GetLabel())));  
  if(!mctrack) return;
@@ -1082,7 +1080,7 @@ void AliHFEdca::FillHistogramsVtx(AliESDEvent *const esdEvent, AliMCEvent *const
 }
 
 //_______________________________________________________________________________________________
-void AliHFEdca::FillHistogramsPid(AliESDtrack * const track, AliMCEvent * const mcEvent)
+void AliHFEdca::FillHistogramsPid(AliESDtrack * const track, const AliMCEvent * const mcEvent)
 {
 
 
@@ -1152,7 +1150,7 @@ void AliHFEdca::FillHistogramsDataDca(AliESDEvent * const esdEvent, AliESDtrack
  Double_t covardz[3];
 
  if(!track->PropagateToDCA(primVtx,magneticField, beampiperadius, dz, covardz)) return;  // protection
- track->PropagateToDCA(primVtx,magneticField, beampiperadius, dz, covardz);
+
 
  Double_t pull[2] = {0, 0};
  Double_t error[2] ={TMath::Sqrt(covardz[0]), TMath::Sqrt(covardz[2])};
@@ -1165,7 +1163,6 @@ void AliHFEdca::FillHistogramsDataDca(AliESDEvent * const esdEvent, AliESDtrack
  Double_t dzwo[2], covardzwo[3];
  Double_t pullwo[2] = {0, 0};
  if(!track->PropagateToDCA(vtxESDSkip, magneticField, beampiperadius, dzwo, covardzwo)) return;   // protection
- track->PropagateToDCA(vtxESDSkip, magneticField, beampiperadius, dzwo, covardzwo); 
 
  Double_t errorwo[2] ={TMath::Sqrt(TMath::Abs(covardzwo[0])), TMath::Sqrt(TMath::Abs(covardzwo[2]))};
  for(Int_t i=0; i<2; i++){
@@ -1477,7 +1474,7 @@ void AliHFEdca::CreateHistogramsHfeDataDca(TList *hfeDataDcaList){
    } // 2 particle type
  } // 2 dca var
 
- fHistDataHfePid[2] = 0x0; //!  HFE pid  
+ //fHistDataHfePid[2] = 0x0; //!  HFE pid  
  for(Int_t iPart=0; iPart<2; iPart++){
    TString histTitleHfe((const char*)fgkParticles[iPart*5]);
    histTitleHfe+=Form("_Data_HfePid_esdPt;p_{T} [GeV/c];counts");
@@ -1537,7 +1534,6 @@ void AliHFEdca::FillHistogramsHfeDca(AliESDEvent * const esdEvent, AliESDtrack *
  Double_t dz[2];   // error of dca in cm
  Double_t covardz[3];
  if(!track->PropagateToDCA(primVtx,magneticField, beampiperadius, dz, covardz)) return; // protection
- track->PropagateToDCA(primVtx,magneticField, beampiperadius, dz, covardz);
 
  AliMCParticle *mctrack = dynamic_cast<AliMCParticle *>(mcEvent->GetTrack(TMath::Abs(track->GetLabel())));  
  if(!mctrack) return;
@@ -1613,7 +1609,7 @@ void AliHFEdca::FillHistogramsHfeDca(AliESDEvent * const esdEvent, AliESDtrack *
 
 
 //_______________________________________________________________________________________________
-void AliHFEdca::FillHistogramsHfeDataDca(AliESDEvent * const esdEvent, AliESDtrack * const track)
+void AliHFEdca::FillHistogramsHfeDataDca(AliESDEvent * const esdEvent, AliESDtrack * const track, AliESDVertex * const vtxESDSkip)
 {
 // filling historgams track by track
 // obtaining reconstructed dca --------------------------------------------------------------
@@ -1624,7 +1620,7 @@ void AliHFEdca::FillHistogramsHfeDataDca(AliESDEvent * const esdEvent, AliESDtra
  Int_t charge = track->Charge();
 
 // obtaining errors of dca ------------------------------------------------------------------
- const AliESDVertex *primVtx = esdEvent->GetPrimaryVertex();      
+ const AliESDVertex *primVtx = esdEvent->GetPrimaryVertex(); // UNUSED!     
  Double_t primV[3];
  primV[0] = primVtx->GetXv();
  primV[1] = primVtx->GetYv();
@@ -1633,15 +1629,16 @@ void AliHFEdca::FillHistogramsHfeDataDca(AliESDEvent * const esdEvent, AliESDtra
  Float_t magneticField = 0;  // initialized as 5kG
  magneticField = esdEvent->GetMagneticField();  // in kG
  Double_t beampiperadius=3.; 
+
  Double_t dz[2];   // error of dca in cm
  Double_t covardz[3];
- if(!track->PropagateToDCA(primVtx,magneticField, beampiperadius, dz, covardz)) return; // protection
- track->PropagateToDCA(primVtx,magneticField, beampiperadius, dz, covardz);
+
+ if(!track->PropagateToDCA(vtxESDSkip,magneticField, beampiperadius, dz, covardz)) return; // protection
 
  Double_t pull[2] = {0, 0};
  Double_t error[2] ={TMath::Sqrt(covardz[0]), TMath::Sqrt(covardz[2])};
  for(Int_t i=0; i<2; i++){
-   if(error[i]!=0)pull[i] = dz[i]/error[i];   // unitless                                                
+   if(error[i]!=0) pull[i] = dz[i]/error[i];   // unitless    
  }
 
  Int_t iPart = -1;
@@ -1660,8 +1657,7 @@ void AliHFEdca::FillHistogramsHfeDataDca(AliESDEvent * const esdEvent, AliESDtra
      fHistHPDataDcaZPull[iPart][iPtBin]->Fill(pull[1]);                      
 
    }
-   else
-     continue;
+   else continue;
  }
 
  fHistDataHfePid[iPart]->Fill(esdpt);
index a6446b3..697606a 100644 (file)
@@ -90,16 +90,16 @@ class AliHFEdca : public TObject{
   void InitAnalysis();  
   void FillHistogramsDca(AliESDEvent *esdEvent,  AliESDtrack *track,  AliMCEvent *mcEvent);
   void FillHistogramsVtx(AliESDEvent *esdEvent,  AliMCEvent *mcEvent);
-  void FillHistogramsPid(AliESDtrack *track,  AliMCEvent *mcEvent);
+  void FillHistogramsPid(AliESDtrack *track, const  AliMCEvent *mcEvent);
 
-  void FillHistogramsKfDca(AliESDEvent *esdEvent,  AliESDtrack *track,  AliMCEvent *mcEvent);
+  void FillHistogramsKfDca(AliESDEvent *esdEvent,  AliESDtrack *track,  const AliMCEvent *mcEvent);
 
   void FillHistogramsDataDca(AliESDEvent *esdEvent,  AliESDtrack *track, AliESDVertex *vtxESDSkip);
   void FillHistogramsDataVtx(AliESDEvent *esdEvent);
   void FillHistogramsDataPid(AliESDtrack *track);
 
   void FillHistogramsHfeDca(AliESDEvent *esdEvent,  AliESDtrack *track,  AliMCEvent *mcEvent);
-  void FillHistogramsHfeDataDca(AliESDEvent *esdEvent,  AliESDtrack *track);
+  void FillHistogramsHfeDataDca(AliESDEvent *esdEvent,AliESDtrack *track,AliESDVertex *vtxESDSkip);
 
 
   void ApplyExtraCuts(AliESDEvent * const esdEvent, Int_t nMinPrimVtxContributor);
index abc5561..e0a6326 100644 (file)
@@ -36,8 +36,7 @@ ClassImp(AliHFEdetPIDqa)
 //____________________________________________________________
 AliHFEdetPIDqa::AliHFEdetPIDqa():
     TNamed()
-  , fESDpid(NULL)
-  , fAODpid(NULL)
+  , fQAmanager(NULL)
 {
   //
   // Dummy constructor
@@ -47,8 +46,7 @@ AliHFEdetPIDqa::AliHFEdetPIDqa():
 //____________________________________________________________
 AliHFEdetPIDqa::AliHFEdetPIDqa(const Char_t *name, const Char_t *title):
     TNamed(name, title)
-  , fESDpid(NULL)
-  , fAODpid(NULL)
+  , fQAmanager(NULL)
 {
   //
   // Default constructor
@@ -58,8 +56,7 @@ AliHFEdetPIDqa::AliHFEdetPIDqa(const Char_t *name, const Char_t *title):
 //____________________________________________________________
 AliHFEdetPIDqa::AliHFEdetPIDqa(const AliHFEdetPIDqa &o):
     TNamed(o)
-  , fESDpid(o.fESDpid)
-  , fAODpid(o.fAODpid)
+  , fQAmanager(o.fQAmanager)
 {
   //
   // Copy constructor
@@ -73,9 +70,7 @@ AliHFEdetPIDqa &AliHFEdetPIDqa::operator=(const AliHFEdetPIDqa &o){
   //
   TNamed::operator=(o);
 
-  fESDpid = o.fESDpid;
-  fAODpid = o.fAODpid;
-  
+  fQAmanager = o.fQAmanager;
   return *this;
 }
 
index 23bcfa7..a210663 100644 (file)
@@ -25,9 +25,8 @@
 #include <TNamed.h>
 #endif
 
-class AliAODpidUtil;
-class AliESDpid;
 class AliHFEpidObject;
+class AliHFEpidQAmanager;
 
 class AliHFEdetPIDqa : public TNamed{
   public:
@@ -42,16 +41,13 @@ class AliHFEdetPIDqa : public TNamed{
     ~AliHFEdetPIDqa(){}
 
     virtual void Initialize() = 0;
-    virtual void ProcessTrack(AliHFEpidObject *track, EStep_t step)= 0;
+    virtual void ProcessTrack(const AliHFEpidObject *track, EStep_t step)= 0;
 
-    void SetESDpid(AliESDpid *esdpid) { fESDpid = esdpid; }
-    void SetAODpid(AliAODpidUtil *aodpid) { fAODpid = aodpid; }
-    AliESDpid *GetESDpid() const { return fESDpid; }
-    AliAODpidUtil *GetAODpid() const { return fAODpid; }
+    void SetPIDqaManager(AliHFEpidQAmanager *qamgr) { fQAmanager = qamgr; }
+    AliHFEpidQAmanager *GetPIDqaManager() const { return fQAmanager; }
 
   protected:
-    AliESDpid     *fESDpid;       //! ESD PID object
-    AliAODpidUtil *fAODpid;       //! AOD PID object
+    AliHFEpidQAmanager *fQAmanager; // PID QA manager
   
     ClassDef(AliHFEdetPIDqa, 1)     // Base class for detector PID QA
 };
index 5588a66..f8160c3 100644 (file)
@@ -302,7 +302,6 @@ void AliHFEdisplacedElectrons::CreateOutputs(TList* const displacedList){
   fTHnSparseDcaEsdEleInfo->SetBinEdges(8, binLimStat);
   fTHnSparseDcaEsdEleInfo->Sumw2();
   
-  printf(" CCCCCCCCCCCCCCCCCCCCCCCCCC \n");
 
   // for ESD data: HFE pid
   const Int_t nVarData = 6;
@@ -933,7 +932,7 @@ Int_t AliHFEdisplacedElectrons::CheckCharm(AliStack * const stack, Int_t eleLabe
 }
 
 //__________________________________________________________
-Bool_t AliHFEdisplacedElectrons::IsB(Int_t pdg)
+Bool_t AliHFEdisplacedElectrons::IsB(Int_t pdg) const
 {
   // check if the pdg is that of a beauty particle
  
@@ -945,7 +944,7 @@ Bool_t AliHFEdisplacedElectrons::IsB(Int_t pdg)
 } 
 
 //__________________________________________________________
-Bool_t AliHFEdisplacedElectrons::IsC(Int_t pdg)
+Bool_t AliHFEdisplacedElectrons::IsC(Int_t pdg) const
 {
   // check if the pdg is that of a charmed particle
    
index e681653..3767675 100644 (file)
@@ -129,8 +129,8 @@ class AliHFEdisplacedElectrons : public TObject{
  
 
   Int_t CheckCharm(AliStack *const stack, Int_t eleLabel);
-  Bool_t IsB(Int_t pdg);
-  Bool_t IsC(Int_t pdg);
+  Bool_t IsB(Int_t pdg) const;
+  Bool_t IsC(Int_t pdg) const;
  
   Int_t ElectronFromSource(AliStack *stack, Int_t eleLabel) const;
   Int_t ElePhotonDirect(AliStack *stack, Int_t label) const;
index 1ff61a9..06f8782 100644 (file)
@@ -246,6 +246,13 @@ Bool_t AliHFEpid::IsSelected(AliHFEpidObject *track, AliHFEcontainer *cont, cons
         AliDebug(2, Form("MC Information available, Filling container %s", mccontname));
         if(fVarManager->IsSignalTrack())
           fVarManager->FillContainerStepname(cont, mccontname, SortedDetectorName(idet), kTRUE);
+       if(cont->GetCorrelationMatrix("correlationstepafterTOF")){
+         TString tstept("TOFPID"); 
+         if(!tstept.CompareTo(SortedDetectorName(idet))) {
+           fVarManager->FillCorrelationMatrix(cont->GetCorrelationMatrix("correlationstepafterTOF"));
+           //printf("Step %s\n",(const char*) SortedDetectorName(idet));
+         }
+       }
       }
       // The PID will NOT fill the double counting information
     }
index ea568cd..545d944 100644 (file)
@@ -80,7 +80,7 @@ class AliHFEpid : public TNamed{
     void PrintStatus() const;
     const Char_t *SortedDetectorName(Int_t det) const {
       if(det < kNdetectorPID) return fgkDetectorName[fSortedOrder[det]]; 
-      else return fgkDetectorName[kNdetectorPID + 1];
+      else return fgkDetectorName[kNdetectorPID];
     }    
     //-----Configure PID detectors with predefined stettings------
     void ConfigureTPCasymmetric(Double_t pmin = 0.1, Double_t pmax = 20., Double_t sigmamin = -0.2, Double_t sigmamax = 5.);
index 720e8fb..27c36d0 100644 (file)
@@ -81,7 +81,7 @@ class AliHFEpidBase : public TNamed{
     virtual ~AliHFEpidBase() {};
     // Framework functions that have to be implemented by the detector PID classes
     virtual Bool_t InitializePID() = 0;
-    virtual Int_t IsSelected(AliHFEpidObject *track, AliHFEpidQAmanager *pidqa = NULL) = 0;
+    virtual Int_t IsSelected(const AliHFEpidObject *track, AliHFEpidQAmanager *pidqa = NULL) const = 0;
 
     Bool_t HasMCData() const { return TestBit(kHasMCData); };
 
@@ -89,9 +89,11 @@ class AliHFEpidBase : public TNamed{
     void SetAODpid(AliAODpidUtil * const pid) { fAODpid = pid; }
     void SetHasMCData(Bool_t hasMCdata = kTRUE) { SetBit(kHasMCData,hasMCdata); };
 
+    AliESDpid *GetESDpid() const { return fESDpid; }; 
+
   protected:
-    AliESDpid *fESDpid;                         // ESD PID object
-    AliAODpidUtil *fAODpid;                     // AOD PID object
+    AliESDpid *fESDpid;                         //! ESD PID object
+    AliAODpidUtil *fAODpid;                     //! AOD PID object
     void Copy(TObject &ref) const;
 
   private:
index 8b9bc84..fed3857 100644 (file)
@@ -90,7 +90,7 @@ Bool_t AliHFEpidITS::InitializePID(){
 
 
 //___________________________________________________________________
-Int_t AliHFEpidITS::IsSelected(AliHFEpidObject* /*track*/, AliHFEpidQAmanager* /*pidqa*/){
+Int_t AliHFEpidITS::IsSelected(const AliHFEpidObject* /*track*/, AliHFEpidQAmanager* /*pidqa*/) const {
   //
   // Does PID decision for ITS
   // 
index 55c1db6..d858533 100644 (file)
@@ -34,7 +34,7 @@ class AliHFEpidITS : public AliHFEpidBase{
     virtual ~AliHFEpidITS();
 
     virtual Bool_t InitializePID();
-    virtual Int_t IsSelected(AliHFEpidObject *track, AliHFEpidQAmanager *pidqa);
+    virtual Int_t IsSelected(const AliHFEpidObject *track, AliHFEpidQAmanager *pidqa) const;
 
     Double_t GetITSSignalV1(AliVParticle *track);
     Double_t GetITSSignalV2(AliVParticle *track);
index 2ce9e70..9d61ee4 100644 (file)
@@ -60,7 +60,7 @@ Bool_t AliHFEpidMC::InitializePID(){
 }
 
 //___________________________________________________________________
-Int_t AliHFEpidMC::IsSelected(AliHFEpidObject *track, AliHFEpidQAmanager * /*pidqa*/){
+Int_t AliHFEpidMC::IsSelected(const AliHFEpidObject *track, AliHFEpidQAmanager * /*pidqa*/) const {
   //
   // returns MC PDG Code
   // Functionality implemented in the base class
index 843eee5..6087228 100644 (file)
@@ -33,7 +33,7 @@ class AliHFEpidMC : public AliHFEpidBase{
     virtual ~AliHFEpidMC(){};
     
     virtual Bool_t InitializePID();
-    virtual Int_t IsSelected(AliHFEpidObject *track, AliHFEpidQAmanager *pidqa);
+    virtual Int_t IsSelected(const AliHFEpidObject *track, AliHFEpidQAmanager *pidqa) const;
 
   private:
 
index 6602038..3ee882d 100644 (file)
@@ -1172,7 +1172,7 @@ Double_t AliHFEpidQA::TRDlikeTracklet(Int_t layer, AliESDtrack * const track, Do
   return sum;
 }
 //__________________________________________________________________________
-const Int_t AliHFEpidQA::TRDmomBin(Double_t p){
+Int_t AliHFEpidQA::TRDmomBin(Double_t p) const {
   //
   // compute the momentum bin position
   // 
index cde8b86..412ea4c 100644 (file)
@@ -105,7 +105,7 @@ class AliHFEpidQA : public TObject{
     Int_t GetTenderV0pid(AliESDtrack * const track);
     
     Double_t TRDlikeTracklet(Int_t layer, AliESDtrack * const track, Double_t *likelihood);
-    const Int_t  TRDmomBin(Double_t p);
+    Int_t TRDmomBin(Double_t p) const;
 
  protected:
     Int_t GetMaxPID(const Double_t *pidProbs) const;
index 66abec4..a07bb2b 100644 (file)
@@ -48,6 +48,7 @@ AliHFEpidQAmanager::AliHFEpidQAmanager():
   // Dummy constructor
   //
   memset(fDetPIDqa, 0, sizeof(AliHFEdetPIDqa *) * AliHFEpid::kNdetectorPID);
+  memset(fDetPID, 0, sizeof(AliHFEdetPIDqa *) * AliHFEpid::kNdetectorPID);
   SetOwner(); 
 }
 
@@ -81,6 +82,7 @@ void AliHFEpidQAmanager::Copy(TObject &o) const{
   AliHFEpidQAmanager &target = dynamic_cast<AliHFEpidQAmanager &>(o);
 
   for(Int_t idet = 0; idet < AliHFEpid::kNdetectorPID; idet++){
+    target.fDetPID[idet] = fDetPID[idet]; 
     if(target.fDetPIDqa[idet]) delete target.fDetPIDqa[idet];
     if(fDetPIDqa[idet]) target.CreateDetPIDqa(static_cast<AliHFEpid::EDETtype_t>(idet));
   }
@@ -103,11 +105,15 @@ void AliHFEpidQAmanager::Initialize(AliHFEpid *pid){
   // Initialize PID QA manager according to the detector
   // configuration used in the PID
   //
-  for(Int_t idet = 0; idet < AliHFEpid::kNdetectorPID; idet++)
+  for(Int_t idet = 0; idet < AliHFEpid::kNdetectorPID; idet++){
+    // Initialize Array for detector PID for all detectors
+    fDetPID[idet] = pid->GetDetPID(static_cast<AliHFEpid::EDETtype_t>(idet));
     if(pid->HasDetector(static_cast<AliHFEpid::EDETtype_t>(idet))){
       CreateDetPIDqa(static_cast<AliHFEpid::EDETtype_t>(idet));
       fDetPIDqa[idet]->Initialize();
+      fDetPIDqa[idet]->SetPIDqaManager(this);
     }
+  }
 }
 
 //____________________________________________________________
@@ -131,7 +137,7 @@ void AliHFEpidQAmanager::CreateDetPIDqa(AliHFEpid::EDETtype_t idet){
 }
 
 //____________________________________________________________
-void AliHFEpidQAmanager::ProcessTrack(AliHFEpidObject *track, AliHFEpid::EDETtype_t det, AliHFEdetPIDqa::EStep_t step){
+void AliHFEpidQAmanager::ProcessTrack(const AliHFEpidObject *track, AliHFEpid::EDETtype_t det, AliHFEdetPIDqa::EStep_t step){
   //
   // Process single Track
   //
@@ -158,21 +164,3 @@ TList *AliHFEpidQAmanager::MakeList(const Char_t *name){
   return list;
 }
 
-//____________________________________________________________
-void AliHFEpidQAmanager::SetESDpid(AliESDpid *esdpid){
-  //
-  // Publish ESD PID
-  //
-  for(Int_t idet = 0; idet < AliHFEpid::kNdetectorPID; idet++)
-    if(fDetPIDqa[idet]) fDetPIDqa[idet]->SetESDpid(esdpid);
-}
-
-//____________________________________________________________
-void AliHFEpidQAmanager::SetAODpid(AliAODpidUtil *aodpid){
-  //
-  // Publish AOD PID
-  //
-  for(Int_t idet = 0; idet < AliHFEpid::kNdetectorPID; idet++)
-    if(fDetPIDqa[idet]) fDetPIDqa[idet]->SetAODpid(aodpid);
-}
-
index 1e6d6e0..84440bf 100644 (file)
@@ -47,13 +47,11 @@ class AliHFEpidQAmanager : public TObject{
     ~AliHFEpidQAmanager();
 
     void Initialize(AliHFEpid *pid);
-    void ProcessTrack(AliHFEpidObject *track, AliHFEpid::EDETtype_t det, AliHFEdetPIDqa::EStep_t step);
+    void ProcessTrack(const AliHFEpidObject *track, AliHFEpid::EDETtype_t det, AliHFEdetPIDqa::EStep_t step);
     AliHFEdetPIDqa *GetDetectorPIDqa(AliHFEpid::EDETtype_t detector) const { return fDetPIDqa[detector]; }
+    AliHFEpidBase *GetDetectorPID(AliHFEpid::EDETtype_t detector) const { return fDetPID[detector]; }
     TList *MakeList(const Char_t *name);
 
-    void SetESDpid(AliESDpid *esdpid);
-    void SetAODpid(AliAODpidUtil *aodpid);
-
   protected:
     enum{
       kIsOwner = BIT(14)
@@ -64,7 +62,8 @@ class AliHFEpidQAmanager : public TObject{
     void CreateDetPIDqa(AliHFEpid::EDETtype_t detector);
 
   private:
-    AliHFEdetPIDqa *fDetPIDqa[AliHFEpid::kNdetectorPID]; //!
+    AliHFEdetPIDqa *fDetPIDqa[AliHFEpid::kNdetectorPID]; //! Detector PID QA objects
+    AliHFEpidBase *fDetPID[AliHFEpid::kNdetectorPID];    //  Detector PID objects
 
   ClassDef(AliHFEpidQAmanager, 0)
 };
index 9f749b1..15d7cf3 100644 (file)
@@ -111,7 +111,7 @@ Bool_t AliHFEpidTOF::InitializePID(){
 }
 
 //___________________________________________________________________
-Int_t AliHFEpidTOF::IsSelected(AliHFEpidObject *track, AliHFEpidQAmanager *pidqa)
+Int_t AliHFEpidTOF::IsSelected(const AliHFEpidObject *track, AliHFEpidQAmanager *pidqa) const
 {
   //
   // TOF PID based on n-Sigma cut
@@ -139,8 +139,15 @@ Int_t AliHFEpidTOF::IsSelected(AliHFEpidObject *track, AliHFEpidQAmanager *pidqa
   return pdg;
 }
 
+/////////////////////////////////////////////////////////
+//
+// Wrappers for functions which are not virtual but
+// only available for ESD and AOD case separately
+//
+/////////////////////////////////////////////////////////
+
 //___________________________________________________________________
-Double_t AliHFEpidTOF::NumberOfSigmas(const AliVParticle *track, AliPID::EParticleType species, AliHFEpidObject::AnalysisType_t anaType){
+Double_t AliHFEpidTOF::NumberOfSigmas(const AliVParticle *track, AliPID::EParticleType species, AliHFEpidObject::AnalysisType_t anaType) const {
   //    
   // Get the number of sigmas
   //
@@ -155,3 +162,51 @@ Double_t AliHFEpidTOF::NumberOfSigmas(const AliVParticle *track, AliPID::EPartic
   }
   return nSigmas;
 }
+
+//___________________________________________________________________
+Double_t AliHFEpidTOF::GetTOFsignal(const AliVParticle *track, AliHFEpidObject::AnalysisType_t anatype) const{
+  //
+  // Get the TOF signal
+  //
+  Double_t tofSignal = 0.;
+  if(anatype == AliHFEpidObject::kESDanalysis){
+    // ESD analysis
+    const AliESDtrack *esdtrack = dynamic_cast<const AliESDtrack *>(track);
+    tofSignal = esdtrack->GetTOFsignal();
+  } else {
+    const AliAODTrack *aodtrack = dynamic_cast<const AliAODTrack *>(track);
+    tofSignal = aodtrack->GetDetPid() ? aodtrack->GetDetPid()->GetTOFsignal() : 0.;
+  }
+  return tofSignal;
+}
+
+//___________________________________________________________________
+Double_t AliHFEpidTOF::GetTime0(AliHFEpidObject::AnalysisType_t anatype) const{
+  //
+  // Get Time0
+  //
+  Double_t time0 = 0.;
+  if(anatype == AliHFEpidObject::kESDanalysis){
+    time0 = fESDpid->GetTOFResponse().GetTimeZero();
+  }else {
+    time0 = fAODpid->GetTOFResponse().GetTimeZero();
+  }
+  return time0;
+}
+
+//___________________________________________________________________
+void AliHFEpidTOF::GetIntegratedTimes(const AliVParticle *track, Double_t *times, AliHFEpidObject::AnalysisType_t anatype) const{
+  //
+  // Return integrated times
+  //
+  if(anatype == AliHFEpidObject::kESDanalysis){
+    // ESD analysis
+    const AliESDtrack *esdtrack = dynamic_cast<const AliESDtrack *>(track);
+    esdtrack->GetIntegratedTimes(times);
+  } else {
+    const AliAODTrack *aodtrack = dynamic_cast<const AliAODTrack *>(track);
+    aodtrack->GetDetPid()->GetIntegratedTimes(times);
+  }
+
+}
+
index 829bb52..a43dd45 100644 (file)
@@ -27,13 +27,16 @@ class AliHFEpidTOF : public AliHFEpidBase{
     AliHFEpidTOF &operator=(const AliHFEpidTOF &c);
   
     virtual Bool_t    InitializePID();
-    virtual Int_t     IsSelected(AliHFEpidObject *track, AliHFEpidQAmanager *piqa);
+    virtual Int_t     IsSelected(const AliHFEpidObject *track, AliHFEpidQAmanager *piqa) const;
   
     void SetTOFnSigma(Short_t nSigma) { fNsigmaTOF = nSigma; };
+    Double_t NumberOfSigmas(const AliVParticle *track, AliPID::EParticleType species, AliHFEpidObject::AnalysisType_t anaType) const;
+    Double_t GetTOFsignal(const AliVParticle *track, AliHFEpidObject::AnalysisType_t anatype) const;
+    Double_t GetTime0(AliHFEpidObject::AnalysisType_t anatype) const;
+    void GetIntegratedTimes(const AliVParticle *track, Double_t *times, AliHFEpidObject::AnalysisType_t anatype) const;
 
   protected:
     void Copy(TObject &ref) const;
-    Double_t NumberOfSigmas(const AliVParticle *track, AliPID::EParticleType species, AliHFEpidObject::AnalysisType_t anaType);
   private:
     AliPID        *fPID;           //! PID Object
 
index a0e3b4d..0c7108f 100644 (file)
@@ -29,6 +29,7 @@
 #include <TMath.h>
 
 #include "AliAODpidUtil.h"
+#include "AliAODPid.h"
 #include "AliAODTrack.h"
 #include "AliAODMCParticle.h"
 #include "AliESDtrack.h"
@@ -47,7 +48,6 @@ ClassImp(AliHFEpidTPC)
 AliHFEpidTPC::AliHFEpidTPC() :
   // add a list here
   AliHFEpidBase()
-  , fLineCrossingType(0)
   , fLineCrossingsEnabled(0)
   , fUpperSigmaCut(NULL)
   , fLowerSigmaCut(NULL)
@@ -64,7 +64,6 @@ AliHFEpidTPC::AliHFEpidTPC() :
 AliHFEpidTPC::AliHFEpidTPC(const char* name) :
   // add a list here
   AliHFEpidBase(name)
-  , fLineCrossingType(0)
   , fLineCrossingsEnabled(0)
   , fUpperSigmaCut(NULL)
   , fLowerSigmaCut(NULL)
@@ -84,7 +83,6 @@ AliHFEpidTPC::AliHFEpidTPC(const char* name) :
 //___________________________________________________________________
 AliHFEpidTPC::AliHFEpidTPC(const AliHFEpidTPC &ref) :
   AliHFEpidBase("")
-  , fLineCrossingType(0)
   , fLineCrossingsEnabled(0)
   , fUpperSigmaCut(NULL)
   , fLowerSigmaCut(NULL)
@@ -148,7 +146,7 @@ Bool_t AliHFEpidTPC::InitializePID(){
 }
 
 //___________________________________________________________________
-Int_t AliHFEpidTPC::IsSelected(AliHFEpidObject *track, AliHFEpidQAmanager *pidqa)
+Int_t AliHFEpidTPC::IsSelected(const AliHFEpidObject *track, AliHFEpidQAmanager *pidqa) const
 {
   //
   // For the TPC pid we use the 2-sigma band around the bethe bloch curve
@@ -167,14 +165,12 @@ Int_t AliHFEpidTPC::IsSelected(AliHFEpidObject *track, AliHFEpidQAmanager *pidqa
   // exclude crossing points:
   // Determine the bethe values for each particle species
   Bool_t isLineCrossing = kFALSE;
-  fLineCrossingType = 0;  // default value
   for(Int_t ispecies = 0; ispecies < AliPID::kSPECIES; ispecies++){
     if(ispecies == AliPID::kElectron) continue;
     if(!(fLineCrossingsEnabled & 1 << ispecies)) continue;
     if(TMath::Abs(NumberOfSigmas(track->GetRecTrack(), (AliPID::EParticleType)ispecies, anatype)) < fLineCrossingSigma[ispecies] && TMath::Abs(nsigma) < fNsigmaTPC){
       // Point in a line crossing region, no PID possible, but !PID still possible ;-)
       isLineCrossing = kTRUE;      
-      fLineCrossingType = ispecies;
       break;
     }
   }
@@ -205,25 +201,25 @@ Int_t AliHFEpidTPC::IsSelected(AliHFEpidObject *track, AliHFEpidQAmanager *pidqa
 }
 
 //___________________________________________________________________
-Bool_t AliHFEpidTPC::CutSigmaModel(const AliVParticle *track, AliHFEpidObject::AnalysisType_t anaType){
+Bool_t AliHFEpidTPC::CutSigmaModel(const AliVParticle *track, AliHFEpidObject::AnalysisType_t anaType) const {
   //
   // N SigmaCut using parametrization of the cuts
   //
   Bool_t isSelected = kTRUE;
   Float_t nsigma = NumberOfSigmas(track, AliPID::kElectron, anaType);
-  Double_t p = track->P();
+  Double_t p = GetP(track, anaType);
   if(fUpperSigmaCut && nsigma > fUpperSigmaCut->Eval(p)) isSelected = kFALSE;
   if(fLowerSigmaCut && nsigma < fLowerSigmaCut->Eval(p)) isSelected = kFALSE;
   return isSelected;
 }
 
 //___________________________________________________________________
-Int_t AliHFEpidTPC::Reject(const AliVParticle *track, AliHFEpidObject::AnalysisType_t anaType){
+Int_t AliHFEpidTPC::Reject(const AliVParticle *track, AliHFEpidObject::AnalysisType_t anaType) const{
   //
   // reject particles based on asymmetric sigma cut
   //
   Int_t pdc[AliPID::kSPECIES] = {11,13,211,321,2212};
-  Double_t p = track->P();
+  Double_t p = GetP(track, anaType);
   for(Int_t ispec = 0; ispec < AliPID::kSPECIES; ispec++){
     if(!TESTBIT(fRejectionEnabled, ispec)) continue;
     // Particle rejection enabled
@@ -249,7 +245,7 @@ void AliHFEpidTPC::AddTPCdEdxLineCrossing(Int_t species, Double_t sigma){
 }
 
 //___________________________________________________________________
-Double_t AliHFEpidTPC::NumberOfSigmas(const AliVParticle *track, AliPID::EParticleType species, AliHFEpidObject::AnalysisType_t anaType){
+Double_t AliHFEpidTPC::NumberOfSigmas(const AliVParticle *track, AliPID::EParticleType species, AliHFEpidObject::AnalysisType_t anaType) const {
   //    
   // Get the number of sigmas
   //
@@ -264,3 +260,21 @@ Double_t AliHFEpidTPC::NumberOfSigmas(const AliVParticle *track, AliPID::EPartic
   }
   return nSigmas;
 }
+
+//___________________________________________________________________
+Double_t AliHFEpidTPC::GetP(const AliVParticle *track, AliHFEpidObject::AnalysisType_t anatype) const {
+  //
+  // Get the momentum at the inner wall of the TPC
+  //
+  Double_t p = -1;
+  if(anatype == AliHFEpidObject::kESDanalysis){
+    // ESD analysis: Use Inner Params for the momentum estimate
+    const AliESDtrack *esdtrack = dynamic_cast<const AliESDtrack *>(track);
+    p = esdtrack->GetInnerParam() ? esdtrack->GetInnerParam()->GetP() : esdtrack->P();
+  } else { 
+    // AOD analysis: Use TPC momentum stored in the AliAODpid object
+    const AliAODTrack *aodtrack = dynamic_cast<const AliAODTrack *>(track);
+    p = aodtrack->GetDetPid() ? aodtrack->GetDetPid()->GetTPCmomentum() : aodtrack->P();
+  }
+  return p;
+}
index 94f2c43..e8964c4 100644 (file)
@@ -46,9 +46,7 @@ class AliHFEpidTPC : public AliHFEpidBase{
     virtual ~AliHFEpidTPC();
     
     virtual Bool_t InitializePID();
-    virtual Int_t IsSelected(AliHFEpidObject *track, AliHFEpidQAmanager *pidqa);
-
-    Int_t GetCrossingType() const {return fLineCrossingType; }
+    virtual Int_t IsSelected(const AliHFEpidObject *track, AliHFEpidQAmanager *pidqa) const;
 
     void AddTPCdEdxLineCrossing(Int_t species, Double_t sigma);
     Bool_t HasAsymmetricSigmaCut() const { return TestBit(kAsymmetricSigmaCut);}
@@ -60,12 +58,14 @@ class AliHFEpidTPC : public AliHFEpidBase{
     void SetUpperSigmaCut(TF1 * const model) { fUpperSigmaCut = model; }
     void SetLowerSigmaCut(TF1 * const model) { fLowerSigmaCut = model; }
 
+    Double_t NumberOfSigmas(const AliVParticle *track, AliPID::EParticleType species, AliHFEpidObject::AnalysisType_t) const;
+    Double_t GetP(const AliVParticle *track, AliHFEpidObject::AnalysisType_t anaType) const;
+
   protected:
     void Copy(TObject &o) const;
-    Double_t NumberOfSigmas(const AliVParticle *track, AliPID::EParticleType species, AliHFEpidObject::AnalysisType_t);
-    Int_t Reject(const AliVParticle *track, AliHFEpidObject::AnalysisType_t anaType);
+    Int_t Reject(const AliVParticle *track, AliHFEpidObject::AnalysisType_t anaType) const;
 
-    Bool_t CutSigmaModel(const AliVParticle *track, AliHFEpidObject::AnalysisType_t anaType);
+    Bool_t CutSigmaModel(const AliVParticle *track, AliHFEpidObject::AnalysisType_t anaType) const;
 
   private:
     enum{
@@ -73,7 +73,6 @@ class AliHFEpidTPC : public AliHFEpidBase{
       kRejection = BIT(21)
     };
     Double_t fLineCrossingSigma[AliPID::kSPECIES];          // with of the exclusion point
-    Int_t    fLineCrossingType;                             // 0 for no line crossing, otherwise AliPID of the particle crossing the electron dEdx band
     UChar_t fLineCrossingsEnabled;                          // Bitmap showing which line crossing is set
     TF1 *fUpperSigmaCut;                                    // Upper Sigma Cut
     TF1 *fLowerSigmaCut;                                    // Lower Sigma Cut
index 73b3cb8..02cdbd2 100644 (file)
@@ -28,6 +28,7 @@
 #include <TString.h>
 
 #include "AliAODpidUtil.h"
+#include "AliAODPid.h"
 #include "AliAODTrack.h"
 #include "AliAODMCParticle.h"
 #include "AliESDtrack.h"
@@ -128,7 +129,7 @@ Bool_t AliHFEpidTRD::InitializePID(){
 }
 
 //______________________________________________________
-Int_t AliHFEpidTRD::IsSelected(AliHFEpidObject *track, AliHFEpidQAmanager *pidqa){
+Int_t AliHFEpidTRD::IsSelected(const AliHFEpidObject *track, AliHFEpidQAmanager *pidqa) const {
   //
   // Does PID for TRD alone:
   // PID thresholds based on 90% Electron Efficiency level approximated by a linear 
@@ -160,7 +161,7 @@ Int_t AliHFEpidTRD::IsSelected(AliHFEpidObject *track, AliHFEpidQAmanager *pidqa
 }
 
 //___________________________________________________________________
-Double_t AliHFEpidTRD::GetTRDthresholds(Double_t electronEff, Double_t p){ 
+Double_t AliHFEpidTRD::GetTRDthresholds(Double_t electronEff, Double_t p) const { 
   //
   // Return momentum dependent and electron efficiency dependent TRD thresholds
   // 
@@ -240,7 +241,7 @@ void AliHFEpidTRD::InitParameters1DLQ(){
 }
 
 //___________________________________________________________________
-void AliHFEpidTRD::GetParameters(Double_t electronEff, Double_t *parameters){
+void AliHFEpidTRD::GetParameters(Double_t electronEff, Double_t *parameters) const {
   //
   // return parameter set for the given efficiency bin
   //
@@ -249,7 +250,7 @@ void AliHFEpidTRD::GetParameters(Double_t electronEff, Double_t *parameters){
 }
 
 //___________________________________________________________________
-Double_t AliHFEpidTRD::GetElectronLikelihood(const AliVParticle *track, AliHFEpidObject::AnalysisType_t anaType){
+Double_t AliHFEpidTRD::GetElectronLikelihood(const AliVParticle *track, AliHFEpidObject::AnalysisType_t anaType) const {
   //
   // Get TRD likelihoods for ESD respectively AOD tracks
   //
@@ -265,7 +266,7 @@ Double_t AliHFEpidTRD::GetElectronLikelihood(const AliVParticle *track, AliHFEpi
 }
 
 //___________________________________________________________________
-Double_t AliHFEpidTRD::GetP(const AliVParticle *track, AliHFEpidObject::AnalysisType_t anaType){
+Double_t AliHFEpidTRD::GetP(const AliVParticle *track, AliHFEpidObject::AnalysisType_t anaType) const {
   //
   // Get the Momentum in the TRD
   //
@@ -281,7 +282,25 @@ Double_t AliHFEpidTRD::GetP(const AliVParticle *track, AliHFEpidObject::Analysis
 }
 
 //___________________________________________________________________
-Double_t AliHFEpidTRD::GetTRDSignalV1(const AliESDtrack *track){
+Double_t AliHFEpidTRD::GetChargeLayer(const AliVParticle *track, UInt_t layer, AliHFEpidObject::AnalysisType_t anaType) const {
+  //
+  // Get the Charge in a single TRD layer
+  //
+  if(layer >= 6) return 0.;
+  Double_t charge = 0.;
+  if(anaType == AliHFEpidObject::kESDanalysis){
+    const AliESDtrack *esdtrack = dynamic_cast<const AliESDtrack *>(track);
+    for(Int_t islice = 0; islice < esdtrack->GetNumberOfTRDslices(); islice++) charge += esdtrack->GetTRDslice(static_cast<UInt_t>(layer), islice);
+  } else {
+    const AliAODTrack *aodtrack = dynamic_cast<const AliAODTrack *>(track);
+    AliAODPid *aoddetpid = aodtrack->GetDetPid();
+    for(Int_t islice = 0; islice < aoddetpid->GetTRDnSlices(); islice++) charge += aoddetpid->GetTRDsignal()[layer * aoddetpid->GetTRDnSlices() + islice];
+  }
+  return charge;
+}
+
+//___________________________________________________________________
+Double_t AliHFEpidTRD::GetTRDSignalV1(const AliESDtrack *track) const {
   //
   // Calculation of the TRD Signal via truncated mean
   // Method 1: Take all Slices available
@@ -314,7 +333,7 @@ Double_t AliHFEpidTRD::GetTRDSignalV1(const AliESDtrack *track){
 }
 
 //___________________________________________________________________
-Double_t AliHFEpidTRD::GetTRDSignalV2(const AliESDtrack *track){
+Double_t AliHFEpidTRD::GetTRDSignalV2(const AliESDtrack *track) const {
   //
   // Calculation of the TRD Signal via truncated mean
   // Method 2: Take only first 5 slices per chamber
index 6c89887..4bc85bb 100644 (file)
@@ -57,10 +57,10 @@ class AliHFEpidTRD : public AliHFEpidBase{
     virtual ~AliHFEpidTRD();
     
     virtual Bool_t InitializePID();
-    virtual Int_t IsSelected(AliHFEpidObject *track, AliHFEpidQAmanager *pidqa);
+    virtual Int_t IsSelected(const AliHFEpidObject *track, AliHFEpidQAmanager *pidqa) const;
 
-    Double_t GetTRDSignalV1(const AliESDtrack *track);
-    Double_t GetTRDSignalV2(const AliESDtrack *track);
+    Double_t GetTRDSignalV1(const AliESDtrack *track) const;
+    Double_t GetTRDSignalV2(const AliESDtrack *track) const;
 
     Bool_t IsCalculateTRDSignals() const { return TestBit(kTRDsignals); }
     void SetPIDMethod(PIDMethodTRD_t method) { fPIDMethod = method; };
@@ -68,17 +68,18 @@ class AliHFEpidTRD : public AliHFEpidBase{
     void SetMinP(Double_t p) { fMinP = p; }
     void CalculateTRDSignals(Bool_t docalc) { SetBit(kTRDsignals, docalc); } 
 
-    Double_t GetTRDthresholds(Double_t electronEff, Double_t p);
+    Double_t GetElectronLikelihood(const AliVParticle *track, AliHFEpidObject::AnalysisType_t anaType) const;
+    Double_t GetP(const AliVParticle *track, AliHFEpidObject::AnalysisType_t anaType) const;
+    Double_t GetTRDthresholds(Double_t electronEff, Double_t p) const;
+    Double_t GetChargeLayer(const AliVParticle *track, UInt_t layer, AliHFEpidObject::AnalysisType_t anatype) const;
   protected:
     enum{
       kTRDsignals = BIT(16)
     };
     void Copy(TObject &ref) const;
-    Double_t GetElectronLikelihood(const AliVParticle *track, AliHFEpidObject::AnalysisType_t anaType);
-    Double_t GetP(const AliVParticle *track, AliHFEpidObject::AnalysisType_t anaType);
     void InitParameters();
     void InitParameters1DLQ();
-    void GetParameters(Double_t electronEff, Double_t *parameters);
+    void GetParameters(Double_t electronEff, Double_t *parameters) const;
 
   private:
     static const Double_t fgkVerySmall;                       // Check for 0
index 19294ae..2375f60 100644 (file)
@@ -93,7 +93,7 @@ AliHFEspectrum::~AliHFEspectrum(){
   }
 }
 //____________________________________________________________
-Bool_t AliHFEspectrum::Init(AliHFEcontainer *datahfecontainer,AliHFEcontainer *mchfecontainer,AliHFEcontainer *v0hfecontainer){
+Bool_t AliHFEspectrum::Init(const AliHFEcontainer *datahfecontainer, const AliHFEcontainer *mchfecontainer, const AliHFEcontainer *v0hfecontainer){
   //
   // Init what we need for the correction:
   //
@@ -180,9 +180,9 @@ Bool_t AliHFEspectrum::Init(AliHFEcontainer *datahfecontainer,AliHFEcontainer *m
     TCanvas * ccontaminationspectrum = new TCanvas("contaminationspectrum","contaminationspectrum",1000,700);
     ccontaminationspectrum->Divide(3,1);
     ccontaminationspectrum->cd(1);
-    TH2D * contaminationspectrum2dpteta = (TH2D*)contaminationspectrum->Project(1,0);
-    TH2D * contaminationspectrum2dptphi = (TH2D*)contaminationspectrum->Project(2,0);
-    TH2D * contaminationspectrum2detaphi = (TH2D*)contaminationspectrum->Project(1,2);
+    TH2D * contaminationspectrum2dpteta = (TH2D *) contaminationspectrum->Project(1,0);
+    TH2D * contaminationspectrum2dptphi = (TH2D *) contaminationspectrum->Project(2,0);
+    TH2D * contaminationspectrum2detaphi = (TH2D *) contaminationspectrum->Project(1,2);
     contaminationspectrum2dpteta->SetStats(0);
     contaminationspectrum2dpteta->SetTitle("");
     contaminationspectrum2dpteta->GetXaxis()->SetTitle("#eta");
@@ -316,7 +316,7 @@ Bool_t AliHFEspectrum::Correct(Bool_t subtractcontamination){
     legcorrected->Draw("same");
     ccorrected->cd(2);
     TH1D *correctedTH1D = correctedspectrum->Projection(0);
-    TH1D *alltogetherTH1D = (TH1D*)alltogetherCorrection->Project(0);
+    TH1D *alltogetherTH1D = (TH1D *) alltogetherCorrection->Project(0);
     TH1D* ratiocorrected = (TH1D*)correctedTH1D->Clone();
     ratiocorrected->SetName("ratiocorrected");
     ratiocorrected->SetTitle("");
@@ -399,8 +399,8 @@ AliCFDataGrid* AliHFEspectrum::SubtractBackground(Bool_t setBackground){
     cbackgroundsubtraction->Divide(3,1);
     cbackgroundsubtraction->cd(1);
     gPad->SetLogy();
-    TH1D *measuredTH1Daftersubstraction = (TH1D*)spectrumSubtracted->Project(0);
-    TH1D *measuredTH1Dbeforesubstraction = (TH1D*)dataspectrumbeforesubstraction->Project(0);
+    TH1D *measuredTH1Daftersubstraction = (TH1D *) spectrumSubtracted->Project(0);
+    TH1D *measuredTH1Dbeforesubstraction = (TH1D *) dataspectrumbeforesubstraction->Project(0);
     CorrectFromTheWidth(measuredTH1Daftersubstraction);
     CorrectFromTheWidth(measuredTH1Dbeforesubstraction);
     measuredTH1Daftersubstraction->SetStats(0);
@@ -438,7 +438,7 @@ AliCFDataGrid* AliHFEspectrum::SubtractBackground(Bool_t setBackground){
     ratiomeasuredcontamination->SetLineColor(kBlack);
     ratiomeasuredcontamination->Draw();
     cbackgroundsubtraction->cd(3);
-    TH1D *measuredTH1background = (TH1D*)backgroundGrid->Project(0);
+    TH1D *measuredTH1background = (TH1D *) backgroundGrid->Project(0);
     CorrectFromTheWidth(measuredTH1background);
     measuredTH1background->SetStats(0);
     measuredTH1background->SetTitle("");
@@ -496,8 +496,8 @@ AliCFDataGrid *AliHFEspectrum::CorrectV0Efficiency(AliCFDataGrid* const bgsubpec
     TCanvas * cV0Efficiency = new TCanvas("V0Efficiency","V0Efficiency",1000,700);
     cV0Efficiency->Divide(2,1);
     cV0Efficiency->cd(1);
-    TH1D *afterE = (TH1D*)result->Project(0);
-    TH1D *beforeE = (TH1D*)dataGrid->Project(0);
+    TH1D *afterE = (TH1D *) result->Project(0);
+    TH1D *beforeE = (TH1D *) dataGrid->Project(0);
     afterE->SetStats(0);
     afterE->SetTitle("");
     afterE->GetYaxis()->SetTitle("dN/dp_{T} [(GeV/c)^{-1}]");
@@ -519,7 +519,7 @@ AliCFDataGrid *AliHFEspectrum::CorrectV0Efficiency(AliCFDataGrid* const bgsubpec
     legV0efficiency->AddEntry(afterE,"After Efficiency correction","p");
     legV0efficiency->Draw("same");
     cV0Efficiency->cd(2);
-    TH1D* efficiencyDproj = (TH1D*)efficiencyD->Project(0);
+    TH1D* efficiencyDproj = (TH1D *) efficiencyD->Project(0);
     efficiencyDproj->SetTitle("");
     efficiencyDproj->SetStats(0);
     efficiencyDproj->SetMarkerStyle(25);
@@ -623,7 +623,7 @@ TList *AliHFEspectrum::Unfold(AliCFDataGrid* const bgsubpectrum){
     legres->Draw("same");
     cresidual->cd(2);
     TH1D *residualTH1D = residual->Projection(0);
-    TH1D *measuredTH1D = (TH1D*)dataGridBis->Project(0);
+    TH1D *measuredTH1D = (TH1D *) dataGridBis->Project(0);
     TH1D* ratioresidual = (TH1D*)residualTH1D->Clone();
     ratioresidual->SetName("ratioresidual");
     ratioresidual->SetTitle("");
@@ -686,22 +686,22 @@ AliCFDataGrid *AliHFEspectrum::CorrectForEfficiency(AliCFDataGrid* const bgsubpe
     
     TCanvas * cefficiency = new TCanvas("efficiency","efficiency",1000,700);
     cefficiency->cd(1);
-    TH1D* efficiencymcPIDD = (TH1D*)efficiencymcPID->Project(0);
+    TH1D* efficiencymcPIDD = (TH1D *) efficiencymcPID->Project(0);
     efficiencymcPIDD->SetTitle("");
     efficiencymcPIDD->SetStats(0);
     efficiencymcPIDD->SetMarkerStyle(25);
     efficiencymcPIDD->Draw();
-    TH1D* efficiencymctrackinggeoD = (TH1D*)efficiencymctrackinggeo->Project(0);
+    TH1D* efficiencymctrackinggeoD = (TH1D *) efficiencymctrackinggeo->Project(0);
     efficiencymctrackinggeoD->SetTitle("");
     efficiencymctrackinggeoD->SetStats(0);
     efficiencymctrackinggeoD->SetMarkerStyle(26);
     efficiencymctrackinggeoD->Draw("same");
-    TH1D* efficiencymcallD = (TH1D*)efficiencymcall->Project(0);
+    TH1D* efficiencymcallD = (TH1D *) efficiencymcall->Project(0);
     efficiencymcallD->SetTitle("");
     efficiencymcallD->SetStats(0);
     efficiencymcallD->SetMarkerStyle(27);
     efficiencymcallD->Draw("same");
-    TH1D* efficiencyesdallD = (TH1D*)efficiencyesdall->Project(0);
+    TH1D* efficiencyesdallD = (TH1D *) efficiencyesdall->Project(0);
     efficiencyesdallD->SetTitle("");
     efficiencyesdallD->SetStats(0);
     efficiencyesdallD->SetMarkerStyle(24);
@@ -746,7 +746,7 @@ TGraphErrors *AliHFEspectrum::Normalize(AliCFDataGrid * const spectrum) const {
   //
   if(fNEvents > 0) {
 
-    TH1D* projection = (TH1D*)spectrum->Project(0);
+    TH1D* projection = (TH1D *) spectrum->Project(0);
     CorrectFromTheWidth(projection);
     TGraphErrors *graphError = NormalizeTH1(projection);
     return graphError;
index c18d9b3..03d50ad 100644 (file)
@@ -48,7 +48,7 @@ class AliHFEspectrum : public TNamed{
     ~AliHFEspectrum();
     
 
-    Bool_t Init(AliHFEcontainer *datahfecontainer,AliHFEcontainer *mchfecontainer,AliHFEcontainer *v0hfecontainer=0x0);
+    Bool_t Init(const AliHFEcontainer *datahfecontainer, const AliHFEcontainer *mchfecontainer, const AliHFEcontainer *v0hfecontainer=0x0);
     Bool_t Correct(Bool_t subtractcontamination=kTRUE);
    
     AliCFDataGrid *SubtractBackground(Bool_t setBackground = kFALSE);
index 86725e2..9cef608 100644 (file)
@@ -32,6 +32,7 @@
 #include "AliHFEcontainer.h"
 #include "AliHFEcuts.h"
 #include "AliHFEpid.h"
+#include "AliHFEpidTPC.h"
 #include "AliHFEpidQAmanager.h"
 #include "AliHFEtaggedTrackAnalysis.h"
 #include "AliHFEvarManager.h"
@@ -47,6 +48,7 @@ AliHFEtaggedTrackAnalysis::AliHFEtaggedTrackAnalysis():
   , fPIDqa(NULL)
   , fCuts(NULL)
   , fCFM(NULL)
+  , fClean(kFALSE)
 {
   //
   // Default constructor
@@ -71,6 +73,7 @@ AliHFEtaggedTrackAnalysis::AliHFEtaggedTrackAnalysis(const AliHFEtaggedTrackAnal
   , fPIDqa(ref.fPIDqa)
   , fCuts(ref.fCuts)
   , fCFM(ref.fCFM)
+  , fClean(ref.fClean)
 {
   //
   // Copy constructor
@@ -92,6 +95,7 @@ AliHFEtaggedTrackAnalysis &AliHFEtaggedTrackAnalysis::operator=(const AliHFEtagg
     fPIDqa = ref.fPIDqa;
     fCuts = ref.fCuts;
     fCFM = ref.fCFM;
+    fClean = ref.fClean;
 
     if(ref.fContainer) InitContainer();
    
@@ -175,6 +179,16 @@ void AliHFEtaggedTrackAnalysis::ProcessTrack(AliVParticle *track, Int_t abinitio
   }
   if(survived){
     AliDebug(2, "Use track in the PID");
+    // Try a loose cut to reject pion contamination
+    if(fClean) {
+      if(abinitioPID == AliPID::kElectron){
+       AliHFEpidTPC *pidTPC = (AliHFEpidTPC *) fPID->GetDetPID(AliHFEpid::kTPCpid);
+       if(pidTPC) {
+         Double_t numberOfSigmaTPC = pidTPC->NumberOfSigmas(track,AliPID::kElectron,AliHFEpidObject::kESDanalysis);
+         if(numberOfSigmaTPC < -5) return;
+       }
+      }
+    }
     // Apply PID
     AliHFEpidObject hfetrack;
     hfetrack.SetAnalysisType(AliHFEpidObject::kESDanalysis);
index 32eff8f..b075879 100644 (file)
@@ -45,8 +45,11 @@ class AliHFEtaggedTrackAnalysis : public TObject{
     AliHFEpidQAmanager *GetPIDqa() const { return fPIDqa; }
     TList * GetPIDQA() const;
     TList * GetCutQA() const;
+    Bool_t  GetClean() const { return fClean; }; 
+
     void SetCuts(AliHFEcuts *cuts);
     void SetPID(AliHFEpid *pid);
+    void SetClean(Bool_t clean) { fClean = clean; };
 
   private:
     enum{
@@ -59,6 +62,7 @@ class AliHFEtaggedTrackAnalysis : public TObject{
     AliHFEpidQAmanager  *fPIDqa;        // PID monitoring
     AliHFEcuts          *fCuts;         // Single track cuts
     AliCFManager        *fCFM;          // CF Manager used for the track filtering
+    Bool_t               fClean;        // Clean
     
   ClassDef(AliHFEtaggedTrackAnalysis, 0)
 };
index 5c46166..a9f7e95 100644 (file)
 #include <THnSparse.h>
 #include <TString.h>
 
-#include "AliAODTrack.h"
-#include "AliESDtrack.h"
-#include "AliESDpid.h"
 #include "AliLog.h"
 #include "AliPID.h"
-#include "AliTOFPIDResponse.h"
+#include "AliVParticle.h"
 
 #include "AliHFEcollection.h"
+#include "AliHFEpid.h"
 #include "AliHFEpidBase.h"
+#include "AliHFEpidQAmanager.h"
+#include "AliHFEpidTPC.h"
+#include "AliHFEpidTOF.h"
 #include "AliHFEtools.h"
 #include "AliHFEtofPIDqa.h"
 
+ClassImp(AliHFEpidTOF)
+
 //_________________________________________________________
 AliHFEtofPIDqa::AliHFEtofPIDqa():
     AliHFEdetPIDqa()
@@ -57,7 +60,7 @@ AliHFEtofPIDqa::AliHFEtofPIDqa():
 
 //_________________________________________________________
 AliHFEtofPIDqa::AliHFEtofPIDqa(const char* name):
-    AliHFEdetPIDqa(name, "QA for TPC")
+    AliHFEdetPIDqa(name, "QA for TOF")
   , fHistos(NULL)
 {
   //
@@ -141,7 +144,7 @@ void AliHFEtofPIDqa::Initialize(){
 
   // Make common binning
   const Int_t kPIDbins = AliPID::kSPECIES + 1;
-  const Int_t kPbins = 1000;
+  const Int_t kPbins = 100;
   const Int_t kSteps = 2;
   const Double_t kMinPID = -1;
   const Double_t kMinP = 0.;
@@ -149,7 +152,7 @@ void AliHFEtofPIDqa::Initialize(){
   const Double_t kMaxP = 20.;
   
   // 1st histogram: TOF sigmas: (species, p nsigma, step)
-  const Int_t kSigmaBins = 1400;
+  const Int_t kSigmaBins = 240;
   Int_t nBinsSigma[4] = {kPIDbins, kPbins, kSigmaBins, kSteps};
   Double_t minSigma[4] = {kMinPID, kMinP, -12., 0};
   Double_t maxSigma[4] = {kMaxPID, kMaxP, 12., 2.};
@@ -163,53 +166,36 @@ void AliHFEtofPIDqa::Initialize(){
 }
 
 //_________________________________________________________
-void AliHFEtofPIDqa::ProcessTrack(AliHFEpidObject *track, AliHFEdetPIDqa::EStep_t step){
+void AliHFEtofPIDqa::ProcessTrack(const AliHFEpidObject *track, AliHFEdetPIDqa::EStep_t step){
   //
   // Fill TPC histograms
   //
-  const AliVParticle *rectrack = track->GetRecTrack();
+  AliHFEpidObject::AnalysisType_t anatype = track->IsESDanalysis() ? AliHFEpidObject::kESDanalysis : AliHFEpidObject::kAODanalysis;
   Int_t species = track->GetAbInitioPID();
   if(species >= AliPID::kSPECIES) species = -1;
-  if(!TString(rectrack->IsA()->GetName()).CompareTo("AliESDtrack")) ProcessESDtrack(dynamic_cast<const AliESDtrack *>(rectrack), step, species);
-  else if(!TString(rectrack->IsA()->GetName()).CompareTo("AliAODTrack")) ProcessAODtrack(dynamic_cast<const AliAODTrack *>(rectrack), step, species);
-  else  AliWarning(Form("Object type %s not supported\n", rectrack->IsA()->GetName()));
-}
 
-//_________________________________________________________
-void AliHFEtofPIDqa::ProcessESDtrack(const AliESDtrack *track, AliHFEdetPIDqa::EStep_t step, Int_t species){
-  //
-  // Process track as ESD track
-  //
-  if(!fESDpid){
-    AliError("No ESD PID object available");
-    return;
-  }
   AliDebug(1, Form("Monitoring particle of type %d for step %d", species, step));
+  AliHFEpidTOF *tofpid= dynamic_cast<AliHFEpidTOF *>(fQAmanager->GetDetectorPID(AliHFEpid::kTOFpid));
+  AliHFEpidTPC *tpcpid= dynamic_cast<AliHFEpidTPC *>(fQAmanager->GetDetectorPID(AliHFEpid::kTPCpid));
   
   Double_t contentSignal[4];
   contentSignal[0] = species;
-  contentSignal[1] = track->GetInnerParam() ? track->GetInnerParam()->P() : track->P();
-  contentSignal[2] = fESDpid->NumberOfSigmasTOF(track, AliPID::kElectron, fESDpid->GetTOFResponse().GetTimeZero()); 
+  contentSignal[1] = track->GetRecTrack()->P();
+  contentSignal[2] = tofpid->NumberOfSigmas(track->GetRecTrack(), AliPID::kElectron, anatype);
   contentSignal[3] = step;
   (dynamic_cast<THnSparseF *>(fHistos->Get("tofnSigma")))->Fill(contentSignal);
-  Double_t tof = track->GetTOFsignal() - fESDpid->GetTOFResponse().GetTimeZero();
-  Double_t times[AliPID::kSPECIES]; track->GetIntegratedTimes(times);
+  Double_t timeTof = tofpid->GetTOFsignal(track->GetRecTrack(), anatype);
+  Double_t time0 = tofpid->GetTime0(anatype);
+  Double_t tof = timeTof - time0;
+  Double_t times[AliPID::kSPECIES]; tofpid->GetIntegratedTimes(track->GetRecTrack(), times, anatype);
   fHistos->Fill("tofTimeRes",contentSignal[1], tof - times[AliPID::kPion]);
   if(species > -1){
-    contentSignal[2] = fESDpid->NumberOfSigmasTPC(track, AliPID::kElectron);
+    contentSignal[2] = tpcpid->NumberOfSigmas(track->GetRecTrack(), AliPID::kElectron, anatype);
     fHistos->Fill("tofMonitorTPC", contentSignal);
   }
 }
 
 //_________________________________________________________
-void AliHFEtofPIDqa::ProcessAODtrack(const AliAODTrack * /*track*/, AliHFEdetPIDqa::EStep_t /*step*/, Int_t /*species*/){
-  //
-  // Process track as AOD track
-  //
-  AliInfo("Method implemented soon!");
-}
-
-//_________________________________________________________
 TH2 *AliHFEtofPIDqa::MakeSpectrumNSigma(AliHFEdetPIDqa::EStep_t istep, Int_t species){
   //
   // Plot the Spectrum
index 8c11187..ff2b7db 100644 (file)
@@ -42,7 +42,7 @@ class AliHFEtofPIDqa : public AliHFEdetPIDqa{
     virtual Long64_t Merge(TCollection *col);
   
     virtual void Initialize();
-    virtual void ProcessTrack(AliHFEpidObject *track, AliHFEdetPIDqa::EStep_t step);
+    virtual void ProcessTrack(const AliHFEpidObject *track, AliHFEdetPIDqa::EStep_t step);
 
     TH2 *MakeSpectrumNSigma(AliHFEdetPIDqa::EStep_t step, Int_t species = -1);
     TH1 *GetHistogram(const char *name);
index 0b19a9e..0303432 100644 (file)
 
 #include "AliHFEcollection.h"
 #include "AliHFEpidBase.h"
+#include "AliHFEpidQAmanager.h"
+#include "AliHFEpidTPC.h"
 #include "AliHFEtools.h"
 #include "AliHFEtpcPIDqa.h"
 
+ClassImp(AliHFEtpcPIDqa)
+
 //_________________________________________________________
 AliHFEtpcPIDqa::AliHFEtpcPIDqa():
     AliHFEdetPIDqa()
@@ -65,7 +69,6 @@ AliHFEtpcPIDqa::AliHFEtpcPIDqa(const char* name):
 //_________________________________________________________
 AliHFEtpcPIDqa::AliHFEtpcPIDqa(const AliHFEtpcPIDqa &o):
     AliHFEdetPIDqa(o)
-  , fHistos()
 {
   //
   // Copy constructor
@@ -139,22 +142,22 @@ void AliHFEtpcPIDqa::Initialize(){
   // Make common binning
   const Int_t kNdim = 5;
   const Int_t kPIDbins = AliPID::kSPECIES + 1;
-  const Int_t kPbins = 1000;
+  const Int_t kPbins = 100;
   const Int_t kSteps = 2;
-  const Int_t kCentralityBins = 20;
+  const Int_t kCentralityBins = 11;
   const Double_t kMinPID = -1;
   const Double_t kMinP = 0.;
   const Double_t kMaxPID = (Double_t)AliPID::kSPECIES;
   const Double_t kMaxP = 20.;
   
   // 1st histogram: TPC dEdx: (species, p, dEdx, step)
-  const Int_t kDedxbins = 600;
+  const Int_t kDedxbins = 200;
   Int_t nBinsdEdx[kNdim] = {kPIDbins, kPbins, kDedxbins, kSteps, kCentralityBins};
   Double_t mindEdx[kNdim] =  {kMinPID, kMinP, 0., 0., 0.};
-  Double_t maxdEdx[kNdim] =  {kMaxPID, kMaxP, 300, 2., 100.}; 
+  Double_t maxdEdx[kNdim] =  {kMaxPID, kMaxP, 200, 2., 11.}; 
   fHistos->CreateTHnSparse("tpcDedx", "TPC signal; species; p [GeV/c]; TPC signal [a.u.]; Centrality; Selection Step", kNdim, nBinsdEdx, mindEdx, maxdEdx);
   // 2nd histogram: TPC sigmas: (species, p nsigma, step)
-  const Int_t kSigmaBins = 1400;
+  const Int_t kSigmaBins = 240;
   Int_t nBinsSigma[kNdim] = {kPIDbins, kPbins, kSigmaBins, kSteps, kCentralityBins};
   Double_t minSigma[kNdim] = {kMinPID, kMinP, -12., 0., 0.};
   Double_t maxSigma[kNdim] = {kMaxPID, kMaxP, 12., 2., 100.};
@@ -164,49 +167,43 @@ void AliHFEtpcPIDqa::Initialize(){
 }
 
 //_________________________________________________________
-void AliHFEtpcPIDqa::ProcessTrack(AliHFEpidObject *track, AliHFEdetPIDqa::EStep_t step){
+void AliHFEtpcPIDqa::ProcessTrack(const AliHFEpidObject *track, AliHFEdetPIDqa::EStep_t step){
   //
   // Fill TPC histograms
   //
   AliDebug(1, Form("QA started for TPC PID for step %d", (Int_t)step));
-  Int_t species = track->GetAbInitioPID();
+  AliHFEpidObject::AnalysisType_t anatype = track->IsESDanalysis() ? AliHFEpidObject::kESDanalysis : AliHFEpidObject::kAODanalysis;
   Float_t centrality = track->GetCentrality();
-  const AliVParticle *rectrack = track->GetRecTrack();
+  Int_t species = track->GetAbInitioPID();
   if(species >= AliPID::kSPECIES) species = -1;
-  if(!TString(rectrack->IsA()->GetName()).CompareTo("AliESDtrack")) ProcessESDtrack(dynamic_cast<const AliESDtrack *>(rectrack), step, species, centrality);
-  else if(!TString(rectrack->IsA()->GetName()).CompareTo("AliAODTrack")) ProcessAODtrack(dynamic_cast<const AliAODTrack *>(rectrack), step, species, centrality);
-  else  AliWarning(Form("Object type %s not supported\n", rectrack->IsA()->GetName()));
-}
 
-//_________________________________________________________
-void AliHFEtpcPIDqa::ProcessESDtrack(const AliESDtrack *track, AliHFEdetPIDqa::EStep_t step, Int_t species, Float_t centrality){
-  //
-  // Process track as ESD track
-  //
-  if(!fESDpid){
-    AliError("No ESD PID object available");
-    return;
-  }
-  AliDebug(1, Form("Monitoring particle of type %d for step %d", species, step));
-  
+  AliHFEpidTPC *tpcpid = dynamic_cast<AliHFEpidTPC *>(fQAmanager->GetDetectorPID(AliHFEpid::kTPCpid));
   Double_t contentSignal[5];
   contentSignal[0] = species;
-  contentSignal[1] = track->GetInnerParam() ? track->GetInnerParam()->P() : track->P();
-  contentSignal[2] = track->GetTPCsignal();
+  contentSignal[1] = tpcpid->GetP(track->GetRecTrack(), anatype);
+  contentSignal[2] = GetTPCsignal(track->GetRecTrack(), anatype);
   contentSignal[3] = step;
   contentSignal[4] = centrality;
   (dynamic_cast<THnSparseF *>(fHistos->Get("tpcDedx")))->Fill(contentSignal);
 
-  contentSignal[2] = fESDpid->NumberOfSigmasTPC(track, AliPID::kElectron); 
+  contentSignal[2] = tpcpid->NumberOfSigmas(track->GetRecTrack(), AliPID::kElectron, anatype); 
   (dynamic_cast<THnSparseF *>(fHistos->Get("tpcnSigma")))->Fill(contentSignal);
 }
 
 //_________________________________________________________
-void AliHFEtpcPIDqa::ProcessAODtrack(const AliAODTrack * /*track*/, AliHFEdetPIDqa::EStep_t /*step*/, Int_t /*species*/, Float_t /*centrality*/){
+Double_t AliHFEtpcPIDqa::GetTPCsignal(const AliVParticle *track, AliHFEpidObject::AnalysisType_t anatype){
   //
-  // Process track as AOD track
+  // Get TPC signal for ESD and AOD track
   //
-  AliInfo("Method implemented soon!");
+  Double_t tpcSignal = 0.;
+  if(anatype == AliHFEpidObject::kESDanalysis){
+    const AliESDtrack *esdtrack = dynamic_cast<const AliESDtrack *>(track);
+    tpcSignal = esdtrack->GetTPCsignal();
+  } else {
+    const AliAODTrack *aodtrack = dynamic_cast<const AliAODTrack *>(track);
+    tpcSignal = aodtrack->GetDetPid() ? aodtrack->GetDetPid()->GetTPCsignal() : 0.;
+  }
+  return tpcSignal;
 }
 
 //_________________________________________________________
index dc3c909..705f993 100644 (file)
 #include "AliHFEdetPIDqa.h"
 #endif
 
+#ifndef ALIHFEPIDBASE_H
+#include "AliHFEpidBase.h"
+#endif
+
 class TH2;
 class AliHFEcollection;
-class AliHFEpidObject;
-class AliESDtrack;
-class AliAODTrack;
+class AliVParticle;
 
 class AliHFEtpcPIDqa : public AliHFEdetPIDqa{
   public:
@@ -41,15 +43,15 @@ class AliHFEtpcPIDqa : public AliHFEdetPIDqa{
     virtual Long64_t Merge(TCollection *col);
   
     virtual void Initialize();
-    virtual void ProcessTrack(AliHFEpidObject *track, AliHFEdetPIDqa::EStep_t step);
+    virtual void ProcessTrack(const AliHFEpidObject *track, AliHFEdetPIDqa::EStep_t step);
 
     AliHFEcollection *GetHistograms() const { return fHistos; }
     TH2 *MakeSpectrumdEdx(AliHFEdetPIDqa::EStep_t step, Int_t species = -1);
     TH2 *MakeSpectrumNSigma(AliHFEdetPIDqa::EStep_t step, Int_t species = -1);
 
   protected:
-    void ProcessESDtrack(const AliESDtrack *track, AliHFEdetPIDqa::EStep_t step, Int_t species, Float_t centrality);
-    void ProcessAODtrack(const AliAODTrack *track, AliHFEdetPIDqa::EStep_t step, Int_t species, Float_t centrality);
+    Double_t GetTPCsignal(const AliVParticle *track, AliHFEpidObject::AnalysisType_t anatype);
+
   private:
     AliHFEcollection *fHistos;        // Container for Histograms
 
index d218c8e..2da9f88 100644 (file)
@@ -37,8 +37,8 @@ class AliMCEvent;
 class AliHFEtrackFilter : public TNamed{
   public:
     AliHFEtrackFilter(const Char_t *name);
-    AliHFEtrackFilter(const AliHFEtrackFilter &);
-    AliHFEtrackFilter &operator=(const AliHFEtrackFilter &);
+    AliHFEtrackFilter(const AliHFEtrackFilter &o);
+    AliHFEtrackFilter &operator=(const AliHFEtrackFilter &o);
     virtual void Copy(TObject &o) const;
     ~AliHFEtrackFilter();
   
index 9e5f170..0ac3d88 100644 (file)
@@ -257,6 +257,7 @@ void AliHFEtrdPIDqa::CreatedEdxHistogram(){
   Double_t binMin[kQuantitiesdEdx]; memcpy(binMin, fgkMinBinCommon, sizeof(Double_t) * kQuantitiesCommon);
   binMin[kdEdx] = 0.;     
   binMin[kNclusters] = 0;
+  binMin[kNonZeroSlices] = 0.;
   Double_t binMax[kQuantitiesdEdx]; memcpy(binMax, fgkMaxBinCommon, sizeof(Double_t) * kQuantitiesCommon);
   binMax[kdEdx] = 100000.;
   binMax[kNclusters] = 260.;
index 72fb759..d528c08 100644 (file)
 #include <THnSparse.h>
 #include <TString.h>
 
-#include "AliAODTrack.h"
-#include "AliESDtrack.h"
-#include "AliESDpid.h"
-#include "AliExternalTrackParam.h"
+#include "AliLog.h"
 #include "AliPID.h"
 
 #include "AliHFEcollection.h"
 #include "AliHFEpidBase.h"
+#include "AliHFEpidQAmanager.h"
+#include "AliHFEpidTPC.h"
+#include "AliHFEpidTRD.h"
 #include "AliHFEtrdPIDqaV1.h"
 
 ClassImp(AliHFEtrdPIDqaV1)
@@ -149,51 +149,32 @@ void AliHFEtrdPIDqaV1::Initialize(){
 }
 
 //____________________________________________________________
-void AliHFEtrdPIDqaV1::ProcessTrack(AliHFEpidObject *track, AliHFEdetPIDqa::EStep_t step){
+void AliHFEtrdPIDqaV1::ProcessTrack(const AliHFEpidObject *track, AliHFEdetPIDqa::EStep_t step){
   //
   // Process the track, fill the containers 
   //
   AliDebug(1, Form("QA started for TRD PID for step %d", (Int_t)step));
   Int_t species = track->GetAbInitioPID();
-  const AliVParticle *rectrack = track->GetRecTrack();
-  if(species >= AliPID::kSPECIES) species = -1;
-  if(!TString(rectrack->IsA()->GetName()).CompareTo("AliESDtrack")) ProcessESDtrack(dynamic_cast<const AliESDtrack *>(rectrack), step, species);
-  else if(!TString(rectrack->IsA()->GetName()).CompareTo("AliAODTrack")) ProcessAODtrack(dynamic_cast<const AliAODTrack *>(rectrack), step, species);
-  else  AliWarning(Form("Object type %s not supported\n", rectrack->IsA()->GetName()));
-}
+  AliHFEpidObject::AnalysisType_t anatype = track->IsESDanalysis() ? AliHFEpidObject::kESDanalysis : AliHFEpidObject::kAODanalysis;
 
-//____________________________________________________________
-void AliHFEtrdPIDqaV1::ProcessESDtrack(const AliESDtrack *track, AliHFEdetPIDqa::EStep_t step, Int_t species){
-  //
-  // Fill QA histograms
-  //
+  AliHFEpidTRD *trdpid = dynamic_cast<AliHFEpidTRD *>(fQAmanager->GetDetectorPID(AliHFEpid::kTRDpid));
+  AliHFEpidTPC *tpcpid = dynamic_cast<AliHFEpidTPC *>(fQAmanager->GetDetectorPID(AliHFEpid::kTPCpid));
   Double_t container[4];
   container[0] = species;
-  container[1] = track->GetOuterParam() ? track->GetOuterParam()->P() : track->P();
-  container[2] = fESDpid->NumberOfSigmasTPC(track, AliPID::kElectron);
+  container[1] = trdpid->GetP(track->GetRecTrack(), anatype);
+  container[2] = tpcpid->NumberOfSigmas(track->GetRecTrack(), AliPID::kElectron, anatype);
   container[3] = step;
   fHistos->Fill("hTPCsigma", container);
 
-  Double_t pid[5];
-  track->GetTRDpid(pid);
-  container[2] = pid[AliPID::kElectron];
+  container[2] = trdpid->GetElectronLikelihood(track->GetRecTrack(), anatype);
   fHistos->Fill("hTRDlikelihood", container);
 
-  Double_t charge = 0.;
-  for(Int_t ily = 0; ily < 6; ily++){
-    charge = 0.;
-    for(Int_t isl = 0; isl < track->GetNumberOfTRDslices(); isl++){
-      charge += track->GetTRDslice(ily, isl);
-    }
+  for(UInt_t ily = 0; ily < 6; ily++){
+    container[2] = trdpid->GetChargeLayer(track->GetRecTrack(), ily, anatype);
     fHistos->Fill("hTRDcharge", container);
   }
-}
-
-//_________________________________________________________
-void AliHFEtrdPIDqaV1::ProcessAODtrack(const AliAODTrack * /*track*/, AliHFEdetPIDqa::EStep_t /*step*/, Int_t /*species*/){
-  //
-  // To be implemented
-  //
+ if(species >= AliPID::kSPECIES) species = -1;
 }
 
 //_________________________________________________________
@@ -211,11 +192,11 @@ TH2 *AliHFEtrdPIDqaV1::MakeTPCspectrumNsigma(AliHFEdetPIDqa::EStep_t step, Int_t
     // cut on species (if available)
     histo->GetAxis(0)->SetRange(species + 2, species + 2); // undef + underflow
   }
-  histo->GetAxis(3)->SetRangeUser(species + 1, species + 1);
+  histo->GetAxis(3)->SetRange(step + 1, step + 1); 
 
   TH2 *hSpec = histo->Projection(2, 1);
   // construct title and name
-  TString stepname = step ? "before" : "after";
+  TString stepname = step == AliHFEdetPIDqa::kBeforePID ? "before" : "after";
   TString speciesname = species > -1 && species < AliPID::kSPECIES ? AliPID::ParticleName(species) : "all Particles";
   TString specID = species > -1 && species < AliPID::kSPECIES ? AliPID::ParticleName(species) : "unid";
   TString histname = Form("hSigmaTPC%s%s", specID.Data(), stepname.Data());
@@ -243,11 +224,11 @@ TH2 *AliHFEtrdPIDqaV1::MakeTRDlikelihoodDistribution(AliHFEdetPIDqa::EStep_t ste
     // cut on species (if available)
     histo->GetAxis(0)->SetRange(species + 2, species + 2); // undef + underflow
   }
-  histo->GetAxis(3)->SetRangeUser(species + 1, species + 1);
+  histo->GetAxis(3)->SetRangeUser(step + 1, step + 1);
 
   TH2 *hSpec = histo->Projection(2, 1);
   // construct title and name
-  TString stepname = step ? "before" : "after";
+  TString stepname = step == AliHFEdetPIDqa::kBeforePID ? "before" : "after";
   TString speciesname = species > -1 && species < AliPID::kSPECIES ? AliPID::ParticleName(species) : "all Particles";
   TString specID = species > -1 && species < AliPID::kSPECIES ? AliPID::ParticleName(species) : "unid";
   TString histname = Form("hLikeElTRD%s%s", specID.Data(), stepname.Data());
@@ -275,11 +256,11 @@ TH2 *AliHFEtrdPIDqaV1::MakeTRDchargeDistribution(AliHFEdetPIDqa::EStep_t step, I
     // cut on species (if available)
     histo->GetAxis(0)->SetRange(species + 2, species + 2); // undef + underflow
   }
-  histo->GetAxis(3)->SetRangeUser(species + 1, species + 1);
+  histo->GetAxis(3)->SetRange(step + 1, step + 1);
 
   TH2 *hSpec = histo->Projection(2, 1);
   // construct title and name
-  TString stepname = step ? "before" : "after";
+  TString stepname = step == AliHFEdetPIDqa::kBeforePID ? "before" : "after";
   TString speciesname = species > -1 && species < AliPID::kSPECIES ? AliPID::ParticleName(species) : "all Particles";
   TString specID = species > -1 && species < AliPID::kSPECIES ? AliPID::ParticleName(species) : "unid";
   TString histname = Form("hChargeTRD%s%s", specID.Data(), stepname.Data());
index a02ea15..a711719 100644 (file)
@@ -40,7 +40,7 @@ class AliHFEtrdPIDqaV1 : public AliHFEdetPIDqa{
 
     virtual void Initialize();
     virtual Long64_t Merge(TCollection *coll);
-    virtual void ProcessTrack(AliHFEpidObject *track, AliHFEdetPIDqa::EStep_t step);
+    virtual void ProcessTrack(const AliHFEpidObject *track, AliHFEdetPIDqa::EStep_t step);
 
     TH2 *MakeTPCspectrumNsigma(AliHFEdetPIDqa::EStep_t step, Int_t species = -1);
     TH2 *MakeTRDlikelihoodDistribution(AliHFEdetPIDqa::EStep_t step, Int_t species = -1);
index c3ed37b..ecd974d 100644 (file)
@@ -165,7 +165,7 @@ void AliHFEvarManager::AddVariable(TString name){
   else if(!name.CompareTo("source"))
     fVariables->AddLast(new AliHFEvariable("source", "source", kSource, 4, 0, 4));
   else if(!name.CompareTo("centrality"))
-    fVariables->AddLast(new AliHFEvariable("centrality", "centrality", kCentrality, 20, 0.0, 100.0));
+    fVariables->AddLast(new AliHFEvariable("centrality", "centrality", kCentrality, 11, 0.0, 11.0));
   else if(!name.CompareTo("species"))
     fVariables->AddLast(new AliHFEvariable("species", "species", kSpecies, 6, -1, 5));
 
@@ -173,6 +173,21 @@ void AliHFEvarManager::AddVariable(TString name){
 }
 
 //____________________________________________________________
+Bool_t AliHFEvarManager::IsVariableDefined(TString name){
+  //
+  // Add new variable to the var manager
+  // Value derived via GetValue()
+  //
+   AliDebug(1, Form("Var Name: %s", name.Data()));
+
+   AliHFEvariable *u = (AliHFEvariable *) fVariables->FindObject((const char*)name);
+   if(u) return kTRUE;
+   else return kFALSE;
+  
+   // More to come ...
+}
+
+//____________________________________________________________
 void AliHFEvarManager::DefineVariables(AliHFEcontainer *cont){
        //
        // Define Variables
index 9342490..2e75098 100644 (file)
@@ -59,6 +59,7 @@ public:
   Bool_t IsOwner() const { return TestBit(kOwner); }
 
   void AddVariable(TString name);
+  Bool_t IsVariableDefined(TString name);
   void DefineVariables(AliHFEcontainer *cont);
   void NewTrack(AliVParticle *track, AliVParticle *mcTrack = NULL, Float_t centrality = 99.0, Int_t aprioriPID = -1, Bool_t signal = kTRUE);
   Bool_t IsSignalTrack() const { return fSignalTrack; }