- Added geometrical track cut (can be switched on/off

diff --git a/PWGJE/UserTasks/AliAnalysisTaskIDFragmentationFunction.cxx b/PWGJE/UserTasks/AliAnalysisTaskIDFragmentationFunction.cxx
index cba4963c738d7c417fbb06ec95cdd8bd150f89fa..34ff2db30d00b09175f7b3a876692af3336aed64 100644 (file)
--- a/PWGJE/UserTasks/AliAnalysisTaskIDFragmentationFunction.cxx
+++ b/PWGJE/UserTasks/AliAnalysisTaskIDFragmentationFunction.cxx
@@ -2731,12 +2731,14 @@ void AliAnalysisTaskIDFragmentationFunction::UserExec(Option_t *)
           // fill inclusive tracks XXX, they have the same track cuts!
           AliAODTrack * inclusiveaod  = dynamic_cast<AliAODTrack*>(fTracksRecCutsEfficiency->At(it));
           if(inclusiveaod){
-            Double_t dEdxTPC = pidResponse->IsTunedOnData() ? pidResponse->GetTPCsignalTunedOnData(inclusiveaod) : 
-            inclusiveaod->GetTPCsignal();
+            Double_t dEdxTPC = pidResponse->IsTunedOnData() ? pidResponse->GetTPCsignalTunedOnData(inclusiveaod) 
+                                                            : inclusiveaod->GetTPCsignal();
             
             if (dEdxTPC <= 0)
               continue;
             
+            Bool_t survivedTPCCutMIGeo = AliAnalysisTaskPID::TPCCutMIGeo(inclusiveaod, InputEvent());
+            
             Int_t label = TMath::Abs(inclusiveaod->GetLabel());
             
             // find MC track in our list, if available
@@ -2774,14 +2776,18 @@ void AliAnalysisTaskIDFragmentationFunction::UserExec(Option_t *)
               Double_t value[AliAnalysisTaskPID::kEffNumAxes] = { mcID, gentrack->Pt(), gentrack->Eta(), gentrack->Charge() / 3.,
                                                                   centPercent,
                                                                   -1, -1, -1 };// no jet pT etc since inclusive spectrum 
-              for (Int_t i = 0; i < fNumInclusivePIDtasks; i++)
-                fInclusivePIDtask[i]->FillEfficiencyContainer(value, AliAnalysisTaskPID::kStepRecWithGenCuts);
+              for (Int_t i = 0; i < fNumInclusivePIDtasks; i++) {
+                if (survivedTPCCutMIGeo || !fInclusivePIDtask[i]->GetUseTPCCutMIGeo())
+                  fInclusivePIDtask[i]->FillEfficiencyContainer(value, AliAnalysisTaskPID::kStepRecWithGenCuts);
+              }
                   
               Double_t valueMeas[AliAnalysisTaskPID::kEffNumAxes] = { mcID, inclusiveaod->Pt(), inclusiveaod->Eta(),
                                                                       inclusiveaod->Charge(), centPercent,
                                                                       -1, -1, -1 };// no jet pT etc since inclusive spectrum 
-              for (Int_t i = 0; i < fNumInclusivePIDtasks; i++)
-                fInclusivePIDtask[i]->FillEfficiencyContainer(valueMeas, AliAnalysisTaskPID::kStepRecWithGenCutsMeasuredObs);
+              for (Int_t i = 0; i < fNumInclusivePIDtasks; i++) {
+                if (survivedTPCCutMIGeo || !fInclusivePIDtask[i]->GetUseTPCCutMIGeo())
+                  fInclusivePIDtask[i]->FillEfficiencyContainer(valueMeas, AliAnalysisTaskPID::kStepRecWithGenCutsMeasuredObs);
+              }
             }
           }
         }
@@ -2802,6 +2808,8 @@ void AliAnalysisTaskIDFragmentationFunction::UserExec(Option_t *)
             if (dEdxTPC <= 0)
               continue;
             
+            Bool_t survivedTPCCutMIGeo = AliAnalysisTaskPID::TPCCutMIGeo(inclusiveaod, InputEvent());
+            
             Int_t label = TMath::Abs(inclusiveaod->GetLabel());
 
             // find MC track in our list, if available
@@ -2811,22 +2819,28 @@ void AliAnalysisTaskIDFragmentationFunction::UserExec(Option_t *)
             if (gentrack)
               pdg = gentrack->GetPdgCode();
             
-            for (Int_t i = 0; i < fNumInclusivePIDtasks; i++)
-              fInclusivePIDtask[i]->ProcessTrack(inclusiveaod, pdg, centPercent, -1); // no jet pT since inclusive spectrum 
+            for (Int_t i = 0; i < fNumInclusivePIDtasks; i++) {
+              if (survivedTPCCutMIGeo || !fInclusivePIDtask[i]->GetUseTPCCutMIGeo())
+                fInclusivePIDtask[i]->ProcessTrack(inclusiveaod, pdg, centPercent, -1); // no jet pT since inclusive spectrum 
+            }
             
             if (gentrack) {
               Int_t mcID = AliAnalysisTaskPID::PDGtoMCID(pdg);
               Double_t valueRecAllCuts[AliAnalysisTaskPID::kEffNumAxes] = { mcID, inclusiveaod->Pt(), inclusiveaod->Eta(), 
                                                                             inclusiveaod->Charge(), centPercent,
                                                                             -1, -1, -1 };
-              for (Int_t i = 0; i < fNumInclusivePIDtasks; i++)
-                fInclusivePIDtask[i]->FillEfficiencyContainer(valueRecAllCuts, AliAnalysisTaskPID::kStepRecWithRecCutsMeasuredObs);
+              for (Int_t i = 0; i < fNumInclusivePIDtasks; i++) {
+                if (survivedTPCCutMIGeo || !fInclusivePIDtask[i]->GetUseTPCCutMIGeo())
+                  fInclusivePIDtask[i]->FillEfficiencyContainer(valueRecAllCuts, AliAnalysisTaskPID::kStepRecWithRecCutsMeasuredObs);
+              }
               
               Double_t weight = IsSecondaryWithStrangeMotherMC(gentrack) ? GetMCStrangenessFactorCMS(gentrack) : 1.0;
-              for (Int_t i = 0; i < fNumInclusivePIDtasks; i++)
-                fInclusivePIDtask[i]->FillEfficiencyContainer(valueRecAllCuts, 
-                                                              AliAnalysisTaskPID::kStepRecWithRecCutsMeasuredObsStrangenessScaled,
-                                                              weight);
+              for (Int_t i = 0; i < fNumInclusivePIDtasks; i++) {
+                if (survivedTPCCutMIGeo || !fInclusivePIDtask[i]->GetUseTPCCutMIGeo())
+                  fInclusivePIDtask[i]->FillEfficiencyContainer(valueRecAllCuts, 
+                                                                AliAnalysisTaskPID::kStepRecWithRecCutsMeasuredObsStrangenessScaled,
+                                                                weight);
+              }
               
               if (gentrack->IsPhysicalPrimary()) {
                 // AliAODMCParticle->Charge() calls TParticlePDG->Charge(), which returns the charge in units of e0 / 3
@@ -2837,12 +2851,14 @@ void AliAnalysisTaskIDFragmentationFunction::UserExec(Option_t *)
                 Double_t valuePtResolution[AliAnalysisTaskPID::kPtResNumAxes] = { -1, gentrack->Pt(), inclusiveaod->Pt() };
               
                 for (Int_t i = 0; i < fNumInclusivePIDtasks; i++) {
-                  fInclusivePIDtask[i]->FillEfficiencyContainer(valueRecAllCuts, 
-                                                                AliAnalysisTaskPID::kStepRecWithRecCutsMeasuredObsPrimaries);
-                  fInclusivePIDtask[i]->FillEfficiencyContainer(valueGenAllCuts, 
-                                                                AliAnalysisTaskPID::kStepRecWithRecCutsPrimaries);
-                  
-                  fInclusivePIDtask[i]->FillPtResolution(mcID, valuePtResolution);
+                  if (survivedTPCCutMIGeo || !fInclusivePIDtask[i]->GetUseTPCCutMIGeo()) {
+                    fInclusivePIDtask[i]->FillEfficiencyContainer(valueRecAllCuts, 
+                                                                  AliAnalysisTaskPID::kStepRecWithRecCutsMeasuredObsPrimaries);
+                    fInclusivePIDtask[i]->FillEfficiencyContainer(valueGenAllCuts, 
+                                                                  AliAnalysisTaskPID::kStepRecWithRecCutsPrimaries);
+                    
+                    fInclusivePIDtask[i]->FillPtResolution(mcID, valuePtResolution);
+                  }
                 }
               }
             }
@@ -3104,6 +3120,8 @@ void AliAnalysisTaskIDFragmentationFunction::UserExec(Option_t *)
         if (dEdxTPC <= 0)
           continue;
         
+        Bool_t survivedTPCCutMIGeo = AliAnalysisTaskPID::TPCCutMIGeo(aodtrack, InputEvent());
+            
         Int_t label = TMath::Abs(aodtrack->GetLabel());
 
         // Find MC track in our list, if available
@@ -3122,14 +3140,18 @@ void AliAnalysisTaskIDFragmentationFunction::UserExec(Option_t *)
             
           Double_t valueRecAllCuts[AliAnalysisTaskPID::kEffNumAxes] = { mcID, pT, aodtrack->Eta(), aodtrack->Charge(),
                                                                         centPercent, jetPt, z, xi };
-          for (Int_t i = 0; i < fNumJetPIDtasks; i++)
-            fJetPIDtask[i]->FillEfficiencyContainer(valueRecAllCuts, AliAnalysisTaskPID::kStepRecWithRecCutsMeasuredObs);
+          for (Int_t i = 0; i < fNumJetPIDtasks; i++) {
+            if (survivedTPCCutMIGeo || !fJetPIDtask[i]->GetUseTPCCutMIGeo())
+              fJetPIDtask[i]->FillEfficiencyContainer(valueRecAllCuts, AliAnalysisTaskPID::kStepRecWithRecCutsMeasuredObs);
+          }
           
           Double_t weight = IsSecondaryWithStrangeMotherMC(gentrack) ? GetMCStrangenessFactorCMS(gentrack) : 1.0;
-          for (Int_t i = 0; i < fNumJetPIDtasks; i++)
-            fJetPIDtask[i]->FillEfficiencyContainer(valueRecAllCuts, 
-                                                    AliAnalysisTaskPID::kStepRecWithRecCutsMeasuredObsStrangenessScaled,
-                                                    weight);
+          for (Int_t i = 0; i < fNumJetPIDtasks; i++) {
+            if (survivedTPCCutMIGeo || !fJetPIDtask[i]->GetUseTPCCutMIGeo())
+              fJetPIDtask[i]->FillEfficiencyContainer(valueRecAllCuts, 
+                                                      AliAnalysisTaskPID::kStepRecWithRecCutsMeasuredObsStrangenessScaled,
+                                                      weight);
+          }
           
           if (gentrack->IsPhysicalPrimary()) {
             // AliAODMCParticle->Charge() calls TParticlePDG->Charge(), which returns the charge in units of e0 / 3
@@ -3143,20 +3165,24 @@ void AliAnalysisTaskIDFragmentationFunction::UserExec(Option_t *)
             Double_t valuePtResolution[AliAnalysisTaskPID::kPtResNumAxes] = { jetPt, genPt, pT };
             
             for (Int_t i = 0; i < fNumJetPIDtasks; i++) {
-              fJetPIDtask[i]->FillEfficiencyContainer(valueRecAllCuts,
-                                                      AliAnalysisTaskPID::kStepRecWithRecCutsMeasuredObsPrimaries);
-              fJetPIDtask[i]->FillEfficiencyContainer(valueGenAllCuts,
-                                                      AliAnalysisTaskPID::kStepRecWithRecCutsPrimaries);
-              
-              fJetPIDtask[i]->FillPtResolution(mcID, valuePtResolution);
+              if (survivedTPCCutMIGeo || !fJetPIDtask[i]->GetUseTPCCutMIGeo()) {
+                fJetPIDtask[i]->FillEfficiencyContainer(valueRecAllCuts,
+                                                        AliAnalysisTaskPID::kStepRecWithRecCutsMeasuredObsPrimaries);
+                fJetPIDtask[i]->FillEfficiencyContainer(valueGenAllCuts,
+                                                        AliAnalysisTaskPID::kStepRecWithRecCutsPrimaries);
+                
+                fJetPIDtask[i]->FillPtResolution(mcID, valuePtResolution);
+              }
             }
           }
         }
         
-        for (Int_t i = 0; i < fNumJetPIDtasks; i++)
-          fJetPIDtask[i]->ProcessTrack(aodtrack, pdg, centPercent, jetPt);
+        for (Int_t i = 0; i < fNumJetPIDtasks; i++) {
+          if (survivedTPCCutMIGeo || !fJetPIDtask[i]->GetUseTPCCutMIGeo())
+            fJetPIDtask[i]->ProcessTrack(aodtrack, pdg, centPercent, jetPt);
+        }
         
-        if (fIDFFMode) {
+        if (fIDFFMode && (survivedTPCCutMIGeo || !fJetPIDtask[0]->GetUseTPCCutMIGeo())) {
           // NOTE: Just take particle fraction from first task (should anyway be the same for all tasks)
           Int_t pidWeightedSpecies = fJetPIDtask[0]->GetRandomParticleTypeAccordingToParticleFractions(pT, jetPt,
                                                                                                        centPercent, kTRUE);
@@ -3203,13 +3229,17 @@ void AliAnalysisTaskIDFragmentationFunction::UserExec(Option_t *)
                                        // AliAODMCParticle->Charge() calls TParticlePDG->Charge(), which returns the charge in units of e0 / 3
           Double_t value[AliAnalysisTaskPID::kEffNumAxes] = { mcID, genPt, gentrack->Eta(), gentrack->Charge() / 3.,
                                                               centPercent, jetPt, genZ, genXi };
-          for (Int_t i = 0; i < fNumJetPIDtasks; i++)
-            fJetPIDtask[i]->FillEfficiencyContainer(value, AliAnalysisTaskPID::kStepRecWithGenCuts);
+          for (Int_t i = 0; i < fNumJetPIDtasks; i++) {
+            if (survivedTPCCutMIGeo || !fJetPIDtask[i]->GetUseTPCCutMIGeo())
+              fJetPIDtask[i]->FillEfficiencyContainer(value, AliAnalysisTaskPID::kStepRecWithGenCuts);
+          }
           
           Double_t valueMeas[AliAnalysisTaskPID::kEffNumAxes] = { mcID, measPt, aodtrack->Eta(), aodtrack->Charge(),
                                                                   centPercent, jetPt, measZ, measXi };
-          for (Int_t i = 0; i < fNumJetPIDtasks; i++)
-            fJetPIDtask[i]->FillEfficiencyContainer(valueMeas, AliAnalysisTaskPID::kStepRecWithGenCutsMeasuredObs);
+          for (Int_t i = 0; i < fNumJetPIDtasks; i++) {
+            if (survivedTPCCutMIGeo || !fJetPIDtask[i]->GetUseTPCCutMIGeo())
+              fJetPIDtask[i]->FillEfficiencyContainer(valueMeas, AliAnalysisTaskPID::kStepRecWithGenCutsMeasuredObs);
+          }
         }
       }
          }

diff --git a/PWGJE/UserTasks/AliAnalysisTaskPID.cxx b/PWGJE/UserTasks/AliAnalysisTaskPID.cxx
index aad2491b167434a58e80c2a407dec32e6cbb1513..268302d62f1d60f36f261c589de052ea009c4b8a 100644 (file)
--- a/PWGJE/UserTasks/AliAnalysisTaskPID.cxx
+++ b/PWGJE/UserTasks/AliAnalysisTaskPID.cxx
@@ -877,31 +877,25 @@ void AliAnalysisTaskPID::UserExec(Option_t *)
     
     // Apply detector level track cuts
     //if (track->GetTPCsignalN() < 60)
-    //  continue;//TODO was removed for a while
+    //  continue;
     
+    Double_t dEdxTPC = fPIDResponse->IsTunedOnData() ? fPIDResponse->GetTPCsignalTunedOnData(track) : track->GetTPCsignal();
+    if (dEdxTPC <= 0)
+      continue;
     
     if(fTrackFilter && !fTrackFilter->IsSelected(track))
       continue;
     
-    /*
-    if (fESD) {
-      AliESDtrack* trackESD = fESD->GetTrack(iTracks);
-      if (trackESD) {
-        if (trackESD->GetLengthInActiveZone(1, 1.8, 220, magField) < 120)
-           continue; //TODO NOW TEST
-      }
-    }*/
+    if (fUseTPCCutMIGeo) {
+      if (!TPCCutMIGeo(track, fEvent))
+        continue;
+    }
     
     if(fUsePhiCut) {
       if (!PhiPrimeCut(track, magField))
         continue; // reject track
     }
     
-    Double_t dEdxTPC = fPIDResponse->IsTunedOnData() ? fPIDResponse->GetTPCsignalTunedOnData(track) : track->GetTPCsignal();
-    
-    if (dEdxTPC <= 0)
-      continue;
-    
     Int_t pdg =  0; // = 0 indicates data for the moment
     AliMCParticle* mcTrack = 0x0;
     Int_t mcID = AliPID::kUnknown;
@@ -1852,6 +1846,7 @@ void AliAnalysisTaskPID::PrintSettings(Bool_t printSystematicsSettings) const
   printf("Track cuts: %s\n", fTrackFilter ? fTrackFilter->GetTitle() : "-");
   printf("Eta cut: %.2f <= |eta| <= %.2f\n", GetEtaAbsCutLow(), GetEtaAbsCutUp());
   printf("Phi' cut: %d\n", GetUsePhiCut());
+  printf("TPCCutMIGeo: %d\n", GetUseTPCCutMIGeo());
   
   printf("\n");
   

diff --git a/PWGJE/UserTasks/AliAnalysisTaskPIDV0base.cxx b/PWGJE/UserTasks/AliAnalysisTaskPIDV0base.cxx
index 798742040250ba6d59ae01c8dff9b49588b66136..49e0341eed0454447f870c76d60456514e2bc979 100644 (file)
--- a/PWGJE/UserTasks/AliAnalysisTaskPIDV0base.cxx
+++ b/PWGJE/UserTasks/AliAnalysisTaskPIDV0base.cxx
@@ -13,7 +13,8 @@
 #include "AliMCEvent.h"
 #include "AliESDInputHandler.h"
 #include "AliInputEventHandler.h"
-
+#include "AliVTrack.h"
+#include "AliExternalTrackParam.h"
 #include "AliVVertex.h"
 #include "AliAnalysisFilter.h"
 #include "AliPID.h"
@@ -35,6 +36,10 @@ Contact: bhess@cern.ch
 
 ClassImp(AliAnalysisTaskPIDV0base)
 
+Double_t AliAnalysisTaskPIDV0base::fgCutGeo = 1.;   
+Double_t AliAnalysisTaskPIDV0base::fgCutNcr = 0.85; 
+Double_t AliAnalysisTaskPIDV0base::fgCutNcl = 0.7;  
+
 //________________________________________________________________________
 AliAnalysisTaskPIDV0base::AliAnalysisTaskPIDV0base()
   : AliAnalysisTaskSE()
@@ -45,6 +50,7 @@ AliAnalysisTaskPIDV0base::AliAnalysisTaskPIDV0base()
   , fV0KineCuts(0x0)
   , fIsPbpOrpPb(kFALSE)
   , fUsePhiCut(kFALSE)
+  , fUseTPCCutMIGeo(kFALSE)
   , fZvtxCutEvent(10.0)
   , fEtaCut(0.9)
   , fPhiCutLow(0x0)
@@ -78,6 +84,7 @@ AliAnalysisTaskPIDV0base::AliAnalysisTaskPIDV0base(const char *name)
   , fV0KineCuts(0x0)
   , fIsPbpOrpPb(kFALSE)
   , fUsePhiCut(kFALSE)
+  , fUseTPCCutMIGeo(kFALSE)
   , fZvtxCutEvent(10.0)
   , fEtaCut(0.9)
   , fPhiCutLow(0x0)
@@ -433,3 +440,61 @@ Int_t AliAnalysisTaskPIDV0base::GetV0motherIndex(Int_t trackIndex) const
   
   return fV0motherIndex[trackIndex];
 }
+
+
+//________________________________________________________________________
+Bool_t AliAnalysisTaskPIDV0base::TPCCutMIGeo(const AliVTrack* track, const AliVEvent* evt, TTreeStream* streamer)
+{
+  //
+  // TPC Cut MIGeo
+  //
+
+  if (!track || !evt)
+    return kFALSE;
+  
+  const Short_t sign = track->Charge();
+  Double_t xyz[50];
+  Double_t pxpypz[50];
+  Double_t cv[100];
+
+  track->GetXYZ(xyz);
+  track->GetPxPyPz(pxpypz);
+
+  AliExternalTrackParam* par = new AliExternalTrackParam(xyz, pxpypz, cv, sign);
+  const AliESDtrack dummy;
+
+  const Double_t magField = evt->GetMagneticField();
+  Double_t varGeom = dummy.GetLengthInActiveZone(par, 3, 236, magField, 0, 0);
+  Double_t varNcr  = track->GetTPCClusterInfo(3, 1);
+  Double_t varNcls = track->GetTPCsignalN();
+
+  const Double_t varEval = 130. - 5. * TMath::Abs(1. / track->Pt());
+  Bool_t cutGeom   = varGeom > fgCutGeo * varEval;
+  Bool_t cutNcr    = varNcr  > fgCutNcr * varEval;
+  Bool_t cutNcls   = varNcls > fgCutNcl * varEval;
+
+  Bool_t kout = cutGeom && cutNcr && cutNcls;
+
+  if (streamer) {
+    Double_t dedx = track->GetTPCsignal();
+
+    (*streamer)<<"tree"<<
+      "param.="<< par<<
+      "varGeom="<<varGeom<<
+      "varNcr="<<varNcr<<
+      "varNcls="<<varNcls<<
+      
+      "cutGeom="<<cutGeom<<
+      "cutNcr="<<cutNcr<<
+      "cutNcls="<<cutNcls<<
+      
+      "kout="<<kout<<
+      "dedx="<<dedx<<
+      
+      "\n";
+  }
+  
+  delete par;
+  
+  return kout;
+}

diff --git a/PWGJE/UserTasks/AliAnalysisTaskPIDV0base.h b/PWGJE/UserTasks/AliAnalysisTaskPIDV0base.h
index f7d641854e367a0f8215ec4851a88dc224362507..6c9866033eb158dce9cd4956024ba3d8bb5ad227 100644 (file)
--- a/PWGJE/UserTasks/AliAnalysisTaskPIDV0base.h
+++ b/PWGJE/UserTasks/AliAnalysisTaskPIDV0base.h
@@ -23,6 +23,8 @@ class AliPID;
 class AliAnalysisFilter;\r
 class AliVTrack;\r
 \r
+#include <TTreeStream.h>\r
+#include "AliInputEventHandler.h"\r
 #include "AliTOFPIDResponse.h"\r
 #include "AliAnalysisTaskSE.h"\r
 \r
@@ -47,6 +49,9 @@ class AliAnalysisTaskPIDV0base : public AliAnalysisTaskSE {
   virtual Bool_t GetUsePhiCut() const { return fUsePhiCut; };\r
   virtual void SetUsePhiCut(Bool_t newValue) { fUsePhiCut = newValue; };\r
   \r
+  virtual Bool_t GetUseTPCCutMIGeo() const { return fUseTPCCutMIGeo; };\r
+  virtual void SetUseTPCCutMIGeo(Bool_t newValue) { fUseTPCCutMIGeo = newValue; };\r
+  \r
   virtual Double_t GetEtaCut() const { return fEtaCut; };     \r
   virtual void  SetEtaCut(Double_t etaCut){ fEtaCut = etaCut; };\r
   \r
@@ -66,7 +71,22 @@ class AliAnalysisTaskPIDV0base : public AliAnalysisTaskSE {
   virtual Float_t GetDeltaTOF(const AliVTrack *track, const AliTOFPIDResponse* tofPIDresponse, const Double_t* times, \r
                               AliPID::EParticleType type) const;\r
   \r
+  static Double_t GetCutGeo() { return fgCutGeo; };\r
+  static Double_t GetCutNcr() { return fgCutNcr; };\r
+  static Double_t GetCutNcl() { return fgCutNcl; };\r
+  \r
+  static void SetCutGeo(Double_t value) { fgCutGeo = value; };\r
+  static void SetCutNcr(Double_t value) { fgCutNcr = value; };\r
+  static void SetCutNcl(Double_t value) { fgCutNcl = value; };\r
+  \r
+  static Bool_t TPCCutMIGeo(const AliVTrack* track, const AliVEvent* evt, TTreeStream* streamer = 0x0);\r
+  static Bool_t TPCCutMIGeo(const AliVTrack* track, const AliInputEventHandler* evtHandler, TTreeStream* streamer = 0x0)\r
+    { if (!evtHandler) return kFALSE; return TPCCutMIGeo(track, evtHandler->GetEvent(), streamer); };\r
+  \r
  protected:\r
+  static Double_t fgCutGeo;   // Cut variable for TPCCutMIGeo concerning geometry\r
+  static Double_t fgCutNcr; // Cut variable for TPCCutMIGeo concerning num crossed rows\r
+  static Double_t fgCutNcl;  // Cut variable for TPCCutMIGeo concerning num clusters\r
   \r
   AliVEvent   *fEvent;    //! VEvent object\r
   AliESDEvent *fESD;      //! ESDEvent object, if ESD\r
@@ -77,6 +97,7 @@ class AliAnalysisTaskPIDV0base : public AliAnalysisTaskSE {
   \r
   Bool_t fIsPbpOrpPb;       // Pbp/pPb collision or something else?\r
   Bool_t fUsePhiCut;        // Use cut on phi (useful for TPC)\r
+  Bool_t fUseTPCCutMIGeo;   // Use geometrical cut for TPC \r
   Double_t fZvtxCutEvent;   // Vertex z cut for the event (cm)\r
   Double_t fEtaCut;         // Eta cut\r
   \r
@@ -101,7 +122,7 @@ class AliAnalysisTaskPIDV0base : public AliAnalysisTaskSE {
   AliAnalysisTaskPIDV0base(const AliAnalysisTaskPIDV0base&); // not implemented\r
   AliAnalysisTaskPIDV0base& operator=(const AliAnalysisTaskPIDV0base&); // not implemented\r
   \r
-  ClassDef(AliAnalysisTaskPIDV0base, 1); // example of analysis\r
+  ClassDef(AliAnalysisTaskPIDV0base, 1);\r
 };\r
 \r
 \r