PWGHF/hfe/AliHFEpidTPC.cxx

   1 /**************************************************************************
   2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   3 *                                                                        *
   4 * Author: The ALICE Off-line Project.                                    *
   5 * Contributors are mentioned in the code where appropriate.              *
   6 *                                                                        *
   7 * Permission to use, copy, modify and distribute this software and its   *
   8 * documentation strictly for non-commercial purposes is hereby granted   *
   9 * without fee, provided that the above copyright notice appears in all   *
  10 * copies and that both the copyright notice and this permission notice   *
  11 * appear in the supporting documentation. The authors make no claims     *
  12 * about the suitability of this software for any purpose. It is          *
  13 * provided "as is" without express or implied warranty.                  *
  14 **************************************************************************/
  15 //
  16 // Class for TPC PID
  17 // Implements the abstract base class AliHFEpidBase
  18 //
  19 // Class contains TPC specific cuts and QA histograms
  20 // Two selection strategies are offered: Selection of certain value
  21 // regions in the TPC dE/dx (by IsSelected), and likelihoods
  22 //
  23 // Authors:
  24 //
  25 //   Markus Fasel <M.Fasel@gsi.de>
  26 //   Markus Heide <mheide@uni-muenster.de>
  27 //
  28 #include <TF1.h>
  29 #include <TMath.h>
  30 #include <TH2D.h>
  31
  32 #include "AliTPCdEdxInfo.h"
  33 #include "AliAODPid.h"
  34 #include "AliAODTrack.h"
  35 #include "AliAODMCParticle.h"
  36 #include "AliESDtrack.h"
  37 #include "AliExternalTrackParam.h"
  38 #include "AliLog.h"
  39 #include "AliMCParticle.h"
  40 #include "AliPID.h"
  41 #include "AliPIDResponse.h"
  42
  43 #include "AliHFEpidTPC.h"
  44 #include "AliHFEpidQAmanager.h"
  45
  46 ClassImp(AliHFEpidTPC)
  47
  48 //___________________________________________________________________
  49 AliHFEpidTPC::AliHFEpidTPC() :
  50   // add a list here
  51   AliHFEpidBase()
  52   , fLineCrossingsEnabled(0)
  53   , fkEtaCorrection(NULL)
  54   , fkCentralityCorrection(NULL)
  55   , fkEtaMeanCorrection(NULL)
  56   , fkEtaWidthCorrection(NULL)
  57   , fkCentralityMeanCorrection(NULL)
  58   , fkCentralityWidthCorrection(NULL)
  59   , fkCentralityEtaCorrectionMeanJpsi(NULL)
  60   , fkCentralityEtaCorrectionWidthJpsi(NULL)
  61   , fHasCutModel(kFALSE)
  62   , fUseOnlyOROC(kFALSE)
  63   , fNsigmaTPC(3)
  64   , fRejectionEnabled(0)
  65   , fUsedEdx(kFALSE)
  66 {
  67   //
  68   // default  constructor
  69   //
  70
  71   memset(fkUpperSigmaCut, 0, sizeof(const TF1 *) * 12);
  72   memset(fkLowerSigmaCut, 0, sizeof(const TF1 *) * 12);
  73
  74   memset(fRejection, 0, sizeof(Float_t) * 4 * AliPID::kSPECIES);
  75   memset(fLineCrossingSigma, 0, sizeof(Double_t) * AliPID::kSPECIES);
  76   memset(fPAsigCut, 0, sizeof(Float_t) * 2);
  77   memset(fNAsigmaTPC, 0, sizeof(Float_t) * 2);
  78
  79 }
  80
  81 //___________________________________________________________________
  82 AliHFEpidTPC::AliHFEpidTPC(const char* name) :
  83   // add a list here
  84   AliHFEpidBase(name)
  85   , fLineCrossingsEnabled(0)
  86   , fkEtaCorrection(NULL)
  87   , fkCentralityCorrection(NULL)
  88   , fkEtaMeanCorrection(NULL)
  89   , fkEtaWidthCorrection(NULL)
  90   , fkCentralityMeanCorrection(NULL)
  91   , fkCentralityWidthCorrection(NULL)
  92   , fkCentralityEtaCorrectionMeanJpsi(NULL)
  93   , fkCentralityEtaCorrectionWidthJpsi(NULL)
  94   , fHasCutModel(kFALSE)
  95   , fUseOnlyOROC(kFALSE)
  96   , fNsigmaTPC(3)
  97   , fRejectionEnabled(0)
  98   , fUsedEdx(kFALSE)
  99 {
 100   //
 101   // default  constructor
 102   //
 103   //
 104   memset(fkUpperSigmaCut, 0, sizeof(const TF1 *) * 12);
 105   memset(fkLowerSigmaCut, 0, sizeof(const TF1 *) * 12);
 106
 107   memset(fRejection, 0, sizeof(Float_t) * 4 * AliPID::kSPECIES);
 108   memset(fLineCrossingSigma, 0, sizeof(Double_t) * AliPID::kSPECIES);
 109   memset(fPAsigCut, 0, sizeof(Float_t) * 2);
 110   memset(fNAsigmaTPC, 0, sizeof(Float_t) * 2);
 111 }
 112
 113 //___________________________________________________________________
 114 AliHFEpidTPC::AliHFEpidTPC(const AliHFEpidTPC &ref) :
 115   AliHFEpidBase("")
 116   , fLineCrossingsEnabled(0)
 117   , fkEtaCorrection(NULL)
 118   , fkCentralityCorrection(NULL)
 119   , fkEtaMeanCorrection(NULL)
 120   , fkEtaWidthCorrection(NULL)
 121   , fkCentralityMeanCorrection(NULL)
 122   , fkCentralityWidthCorrection(NULL)
 123   , fkCentralityEtaCorrectionMeanJpsi(NULL)
 124   , fkCentralityEtaCorrectionWidthJpsi(NULL)
 125   , fHasCutModel(ref.fHasCutModel)
 126   , fUseOnlyOROC(ref.fUseOnlyOROC)
 127   , fNsigmaTPC(2)
 128   , fRejectionEnabled(0)
 129   , fUsedEdx(kFALSE)
 130 {
 131   //
 132   // Copy constructor
 133   //
 134   ref.Copy(*this);
 135 }
 136
 137 //___________________________________________________________________
 138 AliHFEpidTPC &AliHFEpidTPC::operator=(const AliHFEpidTPC &ref){
 139   //
 140   // Assignment operator
 141   //
 142   if(this != &ref){
 143     ref.Copy(*this);
 144   }
 145   return *this;
 146 }
 147 //___________________________________________________________________
 148 void AliHFEpidTPC::Copy(TObject &o) const{
 149   //
 150   // Copy function
 151   // called in copy constructor and assigment operator
 152   //
 153   AliHFEpidTPC &target = dynamic_cast<AliHFEpidTPC &>(o);
 154
 155   target.fkEtaCorrection = fkEtaCorrection;
 156   target.fkCentralityCorrection = fkCentralityCorrection;
 157   target.fkEtaMeanCorrection = fkEtaMeanCorrection;
 158   target.fkEtaWidthCorrection = fkEtaWidthCorrection;
 159   target.fkCentralityMeanCorrection = fkCentralityMeanCorrection;
 160   target.fkCentralityWidthCorrection = fkCentralityWidthCorrection;
 161   target.fLineCrossingsEnabled = fLineCrossingsEnabled;
 162   target.fHasCutModel = fHasCutModel;
 163   target.fUseOnlyOROC = fUseOnlyOROC;
 164   target.fNsigmaTPC = fNsigmaTPC;
 165   target.fRejectionEnabled = fRejectionEnabled;
 166
 167   memcpy(target.fkUpperSigmaCut, fkUpperSigmaCut, sizeof(const TF1 *) * 12);
 168   memcpy(target.fkLowerSigmaCut, fkLowerSigmaCut, sizeof(const TF1 *) * 12);
 169
 170   memcpy(target.fLineCrossingSigma, fLineCrossingSigma, sizeof(Double_t) * AliPID::kSPECIES);
 171   memcpy(target.fPAsigCut, fPAsigCut, sizeof(Float_t) * 2);
 172   memcpy(target.fNAsigmaTPC, fNAsigmaTPC, sizeof(Float_t) * 2);
 173
 174   AliHFEpidBase::Copy(target);
 175 }
 176
 177 //___________________________________________________________________
 178 AliHFEpidTPC::~AliHFEpidTPC(){
 179   //
 180   // Destructor
 181   //
 182 }
 183
 184 //___________________________________________________________________
 185 Bool_t AliHFEpidTPC::InitializePID(Int_t /*run*/){
 186   //
 187   // Add TPC dE/dx Line crossings
 188   //
 189   //AddTPCdEdxLineCrossing(AliPID::kKaon, 0.3, 0.018);
 190   //AddTPCdEdxLineCrossing(AliPID::kProton, 0.9, 0.054);
 191   return kTRUE;
 192 }
 193
 194 //___________________________________________________________________
 195 Int_t AliHFEpidTPC::IsSelected(const AliHFEpidObject *track, AliHFEpidQAmanager *pidqa) const
 196 {
 197   //
 198   // For the TPC pid we use the 2-sigma band around the bethe bloch curve
 199   // for electrons
 200   // exclusion of the crossing points
 201   //
 202
 203   if(!fkPIDResponse) return 0;
 204
 205   AliHFEpidObject::AnalysisType_t anatype = track->IsESDanalysis() ? AliHFEpidObject::kESDanalysis : AliHFEpidObject::kAODanalysis;
 206
 207   // Make clone track in order to be able to apply correction
 208   const AliVTrack *rectrack;
 209   AliESDtrack esdtrack;
 210   AliAODTrack aodtrack;
 211   Double_t correctedTPCnSigma=0.;
 212   Bool_t TPCnSigmaCorrected=kFALSE;
 213   if((fkEtaMeanCorrection&&fkEtaWidthCorrection)||
 214      (fkCentralityMeanCorrection&&fkCentralityWidthCorrection)){
 215     TPCnSigmaCorrected=kTRUE;
 216     correctedTPCnSigma=GetCorrectedTPCnSigma(track->GetRecTrack()->Eta(), track->GetMultiplicity(), fkPIDResponse->NumberOfSigmasTPC(track->GetRecTrack(), AliPID::kElectron));
 217   }
 218   // jpsi
 219   if((fkCentralityEtaCorrectionMeanJpsi)&&
 220      (fkCentralityEtaCorrectionWidthJpsi)){
 221     TPCnSigmaCorrected=kTRUE;
 222     correctedTPCnSigma=GetCorrectedTPCnSigmaJpsi(track->GetRecTrack()->Eta(), track->GetMultiplicity(), fkPIDResponse->NumberOfSigmasTPC(track->GetRecTrack(), AliPID::kElectron));
 223   }
 224   if(fkEtaCorrection || fkCentralityCorrection){
 225     // Correction available
 226     // apply it on copy
 227     if(track->IsESDanalysis()){
 228       esdtrack.~AliESDtrack();
 229       new(&esdtrack) AliESDtrack(*(static_cast<const AliESDtrack *>(track->GetRecTrack())));
 230       if(track->IsPbPb() && HasCentralityCorrection())
 231         ApplyCentralityCorrection(&esdtrack, track->GetMultiplicity(), anatype);
 232       if(HasEtaCorrection())
 233         ApplyEtaCorrection(&esdtrack, anatype);
 234       rectrack = &esdtrack;
 235     } else {
 236       aodtrack.~AliAODTrack();
 237       new(&aodtrack) AliAODTrack(*(static_cast<const AliAODTrack *>(track->GetRecTrack())));
 238       if(track->IsPbPb() && HasCentralityCorrection())
 239         ApplyCentralityCorrection(&aodtrack, track->GetMultiplicity(), anatype);
 240       if(HasEtaCorrection())
 241         ApplyEtaCorrection(&aodtrack, anatype);
 242       rectrack = &aodtrack;
 243     }
 244   } else {
 245     // Correction not available - no need to copy
 246     rectrack = track->GetRecTrack();
 247   }
 248   AliHFEpidObject tpctrack(*track);
 249   tpctrack.SetRecTrack(rectrack);
 250   if(TPCnSigmaCorrected)tpctrack.SetCorrectedTPCnSigma(correctedTPCnSigma);
 251
 252   // QA before selection (after correction)
 253   if(pidqa) pidqa->ProcessTrack(&tpctrack, AliHFEpid::kTPCpid, AliHFEdetPIDqa::kBeforePID);
 254   AliDebug(1, "Doing TPC PID based on n-Sigma cut approach");
 255
 256   // make copy of the track in order to allow for applying the correction
 257   Float_t nsigma=correctedTPCnSigma;
 258   if(!TPCnSigmaCorrected)
 259     nsigma = fUsedEdx ? rectrack->GetTPCsignal() : fkPIDResponse->NumberOfSigmasTPC(rectrack, AliPID::kElectron);
 260   AliDebug(1, Form("TPC NSigma: %f", nsigma));
 261   // exclude crossing points:
 262   // Determine the bethe values for each particle species
 263   Bool_t isLineCrossing = kFALSE;
 264   for(Int_t ispecies = 0; ispecies < AliPID::kSPECIES; ispecies++){
 265     if(ispecies == AliPID::kElectron) continue;
 266     if(!(fLineCrossingsEnabled & 1 << ispecies)) continue;
 267     if(TMath::Abs(fkPIDResponse->NumberOfSigmasTPC(rectrack, (AliPID::EParticleType)ispecies)) < fLineCrossingSigma[ispecies] && TMath::Abs(nsigma) < fNsigmaTPC){
 268       // Point in a line crossing region, no PID possible, but !PID still possible ;-)
 269       isLineCrossing = kTRUE;
 270       break;
 271     }
 272   }
 273   if(isLineCrossing) return 0;
 274
 275   // Check particle rejection
 276   if(HasParticleRejection()){
 277     Int_t reject = Reject(rectrack, anatype);
 278     if(reject != 0) return reject;
 279   }
 280
 281   // Check if we have an asymmetric sigma model set
 282   Int_t pdg = 0;
 283   if(fHasCutModel){
 284     pdg = CutSigmaModel(&tpctrack) ? 11 : 0;
 285   } else {
 286     // Perform Asymmetric n-sigma cut if required, else perform symmetric TPC sigma cut
 287     Float_t p = rectrack->P();
 288     if(HasAsymmetricSigmaCut()) {
 289
 290       //printf("p %f, fPAsigCut[0] %f, fPAsigCut[1] %f\n",p,fPAsigCut[0],fPAsigCut[1]);
 291       if(p >= fPAsigCut[0] && p <= fPAsigCut[1]) {
 292               if(nsigma >= fNAsigmaTPC[0] && nsigma <= fNAsigmaTPC[1]) pdg = 11;
 293                 else pdg = 0;
 294       }
 295       else pdg = 0;
 296
 297     }
 298     else {
 299       if(TMath::Abs(nsigma) < fNsigmaTPC ) pdg = 11;
 300     }
 301   }
 302   if(pidqa && pdg != 0) pidqa->ProcessTrack(&tpctrack, AliHFEpid::kTPCpid, AliHFEdetPIDqa::kAfterPID);
 303   return pdg;
 304
 305 }
 306
 307 //___________________________________________________________________
 308 Bool_t AliHFEpidTPC::CutSigmaModel(const AliHFEpidObject * const track) const {
 309   //
 310   // N SigmaCut using parametrization of the cuts
 311   //
 312   Bool_t isSelected = kTRUE;
 313   AliHFEpidObject::AnalysisType_t anatype = track->IsESDanalysis() ? AliHFEpidObject::kESDanalysis : AliHFEpidObject::kAODanalysis;
 314   Float_t nsigma = fUsedEdx ? track->GetRecTrack()->GetTPCsignal() : fkPIDResponse->NumberOfSigmasTPC(track->GetRecTrack(), AliPID::kElectron);
 315   Double_t p = GetP(track->GetRecTrack(), anatype);
 316   Int_t centrality = track->IsPbPb() ? track->GetCentrality() + 1 : 0;
 317   AliDebug(2, Form("Centrality: %d\n", centrality));
 318   if(centrality > 11) return kFALSE;
 319   const TF1 *cutfunction;
 320   if((cutfunction = fkUpperSigmaCut[centrality]) && nsigma > cutfunction->Eval(p)) isSelected = kFALSE;
 321   if((cutfunction = fkLowerSigmaCut[centrality]) && nsigma < cutfunction->Eval(p)) isSelected = kFALSE;
 322   return isSelected;
 323 }
 324
 325 //___________________________________________________________________
 326 Int_t AliHFEpidTPC::Reject(const AliVParticle *track, AliHFEpidObject::AnalysisType_t anaType) const{
 327   //
 328   // reject particles based on asymmetric sigma cut
 329   //
 330   Int_t pdc[AliPID::kSPECIES] = {11,13,211,321,2212};
 331   Double_t p = GetP(track, anaType);
 332   for(Int_t ispec = 0; ispec < AliPID::kSPECIES; ispec++){
 333     if(!TESTBIT(fRejectionEnabled, ispec)) continue;
 334     // Particle rejection enabled
 335     if(p < fRejection[4*ispec] || p > fRejection[4*ispec+2]) continue;
 336     Double_t sigma = fkPIDResponse->NumberOfSigmasTPC(track, static_cast<AliPID::EParticleType>(ispec));
 337     if(sigma >= fRejection[4*ispec+1] && sigma <= fRejection[4*ispec+3]) return pdc[ispec] * track->Charge();
 338   }
 339   return 0;
 340 }
 341
 342 //___________________________________________________________________
 343 void AliHFEpidTPC::ApplyEtaCorrection(AliVTrack *track, AliHFEpidObject::AnalysisType_t anatype) const{
 344   //
 345   // Apply correction for the eta dependence
 346   // N.B. This correction has to be applied on a copy track
 347   //
 348   AliDebug(1, Form("Applying correction function %s\n", fkEtaCorrection->GetName()));
 349   Double_t original = track->GetTPCsignal(),
 350            eta = track->Eta();
 351   if(anatype == AliHFEpidObject::kESDanalysis){
 352     AliESDtrack *esdtrack = static_cast<AliESDtrack *>(track);
 353     if(fkEtaCorrection->Eval(eta)>0.0) esdtrack->SetTPCsignal(original/fkEtaCorrection->Eval(eta), esdtrack->GetTPCsignalSigma(), esdtrack->GetTPCsignalN());
 354   } else {
 355     AliAODTrack *aodtrack = static_cast<AliAODTrack *>(track);
 356     AliAODPid *pid = aodtrack->GetDetPid();
 357     if(pid && fkEtaCorrection->Eval(eta)>0.0) pid->SetTPCsignal(original/fkEtaCorrection->Eval(eta));
 358   }
 359 }
 360
 361 //___________________________________________________________________
 362 void AliHFEpidTPC::ApplyCentralityCorrection(AliVTrack *track, Double_t centralityEstimator, AliHFEpidObject::AnalysisType_t anatype) const{
 363   //
 364   // Apply correction for the eta dependence
 365   // N.B. This correction has to be applied on a copy track
 366   //
 367   AliDebug(1, Form("Applying correction function %s\n", fkCentralityCorrection->GetName()));
 368   Double_t original = track->GetTPCsignal();
 369   if(anatype == AliHFEpidObject::kESDanalysis){
 370     AliESDtrack *esdtrack = static_cast<AliESDtrack *>(track);
 371     if(fkCentralityCorrection->Eval(centralityEstimator)>0.0) esdtrack->SetTPCsignal(original/fkCentralityCorrection->Eval(centralityEstimator), esdtrack->GetTPCsignalSigma(), esdtrack->GetTPCsignalN());
 372   } else {
 373     AliAODTrack *aodtrack = static_cast<AliAODTrack *>(track);
 374     AliAODPid *pid = aodtrack->GetDetPid();
 375     if(pid && fkCentralityCorrection->Eval(centralityEstimator)>0.0) pid->SetTPCsignal(original/fkCentralityCorrection->Eval(centralityEstimator));
 376   }
 377 }
 378
 379 //___________________________________________________________________
 380 Double_t AliHFEpidTPC::GetCorrectedTPCnSigma(Double_t eta, Double_t centralityEstimator, Double_t tpcNsigma) const{
 381   //
 382   // Apply correction for the eta dependence
 383   // N.B. This correction has to be applied on a copy track
 384   //
 385   Double_t corrtpcNsigma = tpcNsigma;
 386   if(fkEtaMeanCorrection&&fkEtaWidthCorrection){
 387     if(TMath::Abs(fkEtaWidthCorrection->Eval(eta))>0.0000001) corrtpcNsigma=(corrtpcNsigma-fkEtaMeanCorrection->Eval(eta))/fkEtaWidthCorrection->Eval(eta);
 388   }
 389   if(fkCentralityMeanCorrection&&fkCentralityWidthCorrection) {
 390     if(TMath::Abs(fkCentralityWidthCorrection->Eval(centralityEstimator))>0.0000001) corrtpcNsigma=(corrtpcNsigma-fkCentralityMeanCorrection->Eval(centralityEstimator))/fkCentralityWidthCorrection->Eval(centralityEstimator);
 391   }
 392   return corrtpcNsigma;
 393 }
 394
 395 //___________________________________________________________________
 396 Double_t AliHFEpidTPC::GetCorrectedTPCnSigmaJpsi(Double_t eta, Double_t centralityEstimator, Double_t tpcNsigma) const{
 397   //
 398   // Apply correction for the eta dependence
 399   // N.B. This correction has to be applied on a copy track
 400   //
 401   Double_t corrtpcNsigma = tpcNsigma;
 402   if(fkCentralityEtaCorrectionMeanJpsi&&fkCentralityEtaCorrectionWidthJpsi){
 403     const TAxis *caxis = fkCentralityEtaCorrectionMeanJpsi->GetXaxis();
 404     const TAxis *eaxis = fkCentralityEtaCorrectionMeanJpsi->GetYaxis();
 405     Int_t cbin = caxis->FindFixBin(centralityEstimator);
 406     Int_t ebin = eaxis->FindFixBin(eta);
 407     //Double_t cbinlowedge = caxis->GetBinLowEdge(cbin);
 408     //Double_t cbinupedge = caxis->GetBinUpEdge(cbin);
 409     //Double_t ebinlowedge = eaxis->GetBinLowEdge(ebin);
 410     //Double_t ebinupedge = eaxis->GetBinUpEdge(ebin);
 411     Double_t center = fkCentralityEtaCorrectionMeanJpsi->GetBinContent(cbin,ebin);
 412     Double_t width = fkCentralityEtaCorrectionWidthJpsi->GetBinContent(cbin,ebin);
 413     //printf("cbin %d, cbinlowe %f, cbinupe %f, centrality %f\n",cbin,cbinlowedge,cbinupedge,centralityEstimator);
 414     //printf("ebin %d, ebinlowe %f, ebinupe %f, eta %f\n",ebin,ebinlowedge,ebinupedge,eta);
 415     //printf("mean %f, width %f\n",center,width);
 416     if(TMath::Abs(width)>0.0000001) corrtpcNsigma=(corrtpcNsigma-center)/width;
 417   }
 418   return corrtpcNsigma;
 419 }
 420
 421 //___________________________________________________________________
 422 void AliHFEpidTPC::UseOROC(AliVTrack *track, AliHFEpidObject::AnalysisType_t anatype) const{
 423   //
 424   // Use TPC signal from the OROC
 425   // N.B. This correction has to be applied on a copy track
 426   //
 427   //Double_t original = track->GetTPCsignal();
 428
 429   if(anatype == AliHFEpidObject::kESDanalysis){
 430     AliESDtrack *esdtrack = static_cast<AliESDtrack *>(track);
 431     AliTPCdEdxInfo *dEdxInfo = track->GetTPCdEdxInfo();
 432     Double32_t  TPCsignalRegion[4]; // TPC dEdx signal in 4 different regions - 0 - IROC, 1- OROC medium, 2 - OROC long, 3- OROC all, (default truncation used)
 433     Char_t      TPCsignalNRegion[3]; // number of clusters above threshold used in the dEdx calculation
 434     Char_t      TPCsignalNRowRegion[3]; // number of crosed rows used in the dEdx calculation - signal below threshold included
 435     dEdxInfo->GetTPCSignalRegionInfo(TPCsignalRegion,TPCsignalNRegion,TPCsignalNRowRegion);
 436     esdtrack->SetTPCsignal(TPCsignalRegion[3],esdtrack->GetTPCsignalSigma(),(TPCsignalNRegion[1]+TPCsignalNRegion[2])); // the two last are not ok
 437   } else {
 438     AliAODTrack *aodtrack = static_cast<AliAODTrack *>(track);
 439     AliTPCdEdxInfo *dEdxInfo = track->GetTPCdEdxInfo();
 440     Double32_t  TPCsignalRegion[4]; // TPC dEdx signal in 4 different regions - 0 - IROC, 1- OROC medium, 2 - OROC long, 3- OROC all, (default truncation used)
 441     Char_t      TPCsignalNRegion[3]; // number of clusters above threshold used in the dEdx calculation
 442     Char_t      TPCsignalNRowRegion[3]; // number of crosed rows used in the dEdx calculation - signal below threshold included
 443     dEdxInfo->GetTPCSignalRegionInfo(TPCsignalRegion,TPCsignalNRegion,TPCsignalNRowRegion);
 444     AliAODPid *pid = aodtrack->GetDetPid();
 445     if(pid) pid->SetTPCsignal(TPCsignalRegion[3]);
 446     if(pid) pid->SetTPCsignalN((TPCsignalNRegion[1]+TPCsignalNRegion[2]));
 447   }
 448
 449 }
 450 //___________________________________________________________________
 451 void AliHFEpidTPC::AddTPCdEdxLineCrossing(Int_t species, Double_t sigma){
 452   //
 453   // Add exclusion point for the TPC PID where a dEdx line crosses the electron line
 454   // Stores line center and line sigma
 455   //
 456   if(species >= AliPID::kSPECIES){
 457     AliError("Species doesn't exist");
 458     return;
 459   }
 460   fLineCrossingsEnabled |= 1 << species;
 461   fLineCrossingSigma[species] = sigma;
 462 }
 463
 464 //___________________________________________________________________
 465 Double_t AliHFEpidTPC::GetP(const AliVParticle *track, AliHFEpidObject::AnalysisType_t anatype) const {
 466   //
 467   // Get the momentum at the inner wall of the TPC
 468   //
 469   Double_t p = -1;
 470   if(anatype == AliHFEpidObject::kESDanalysis){
 471     // ESD analysis: Use Inner Params for the momentum estimate
 472     const AliESDtrack *esdtrack = dynamic_cast<const AliESDtrack *>(track);
 473     if(esdtrack) p = esdtrack->GetInnerParam() ? esdtrack->GetInnerParam()->GetP() : esdtrack->P();
 474   }
 475
 476   if(anatype == AliHFEpidObject::kAODanalysis)
 477   {
 478     // AOD analysis: Use TPC momentum stored in the AliAODpid object
 479     const AliAODTrack *aodtrack = dynamic_cast<const AliAODTrack *>(track);
 480     if(aodtrack) p = aodtrack->GetDetPid() ? aodtrack->GetDetPid()->GetTPCmomentum() : aodtrack->P();
 481   }
 482   return p;
 483 }